Clojure Q&A - Recent activity in Macros

Commented: Adding condp-> and condp->> macros to core library

Wed, 20 May 2026 14:17:09 +0000

This invokes the predicates on the expression. We have a version that _threads_ the expression through the predicate: https://github.com/worldsingles/commons/blob/master/src/ws/clojure/extensions.clj#L24

Closed: Why doesn't defn also implicitly name the anonymous function it defines for recursion?

Thu, 26 Mar 2026 17:24:24 +0000

Why doesn't defn implicitly name the function to create a named recursion point?

(clojure.walk/macroexpand-all
  '(defn foo [x]
     (foo x)))
; =>
(def foo
  (fn*
    ([x]
     (foo x))))

This could instead expand to

(def foo
  (fn* foo ; note the foo here
    ([x]
     (foo x))))

How it works right now, foo resolves to a global var #'foo, which is created when the (def ...) form is analyzed. In the second case, it resolves directly to the function object. Thus, it should save us a var dereference at runtime in this case.

EDIT: Found out, this is exactly what direct linking is used for.

Commented: specifying `:let` as the first element of `for` causes an macro expansion error

Mon, 11 Aug 2025 19:54:20 +0000

Possibly, but the extra check on the vector would be a performance penalty that everyone would pay for every use of `for` in every program -- and Clojure rarely does that to its users.

Comment edited: `cond-let` macro as pair for `if-let`, similar to `if`/`conf` pair

Thu, 08 May 2025 12:35:57 +0000

I do sometimes "need" something like this. Very concrete example:

```
(cond-let
  [search-results1 (check1-involving-heavy-work)] {:result search-results1}
  [search-results2 (check2-involving-heavy-work)] {:result search-results2}
  [search-results3 (check3-involving-heavy-work)] {:result search-results3}
  [search-results4 (check4-involving-heavy-work)] {:result search-results4}
  :else ...)
```

I found this: https://cljdoc.org/d/org.flatland/useful/0.11.6/api/flatland.useful.experimental#cond-let

Not sure why it is "experimental", but this seems to be, well, useful to me :)

(* updated to make example a bit more clear; it's a hypothetical example, don't pin me down on the details and how you could do this exact example differently please :) *)

Retagged: `doseq` and `for` expands body twice

Wed, 05 Mar 2025 18:46:18 +0000

The bodies of doseq and for seem to be duplicated in their expansions.

$ clojure
user=> (defmacro a [] (prn :expand))
#'user/a
user=> (doseq [_ nil] (a))
:expand
:expand
nil
user=> (for [_ nil] (a))
:expand
:expand
()

I found the same problem in ClojureScript. I could not find an existing discussion about this so I'm not sure if this is by design, apologies if so. I'm aware that these macros have a large code footprint and that doseq cannot use closures (the usual way to prevent exponential expansion), but I missed this detail.

This leads to exponential code blowup if these forms are nested. Artificial demonstration:

$ clojure
Clojure 1.12.0
user=> (def counter (atom -1))
#'user/counter
user=> (defmacro a [] (prn :expand (swap! counter inc)))
#'user/a
user=> #(doseq [_ 1] (doseq [_ 2] (doseq [_ 3] (doseq [_ 4] (a)))))
:expand 0
:expand 1
:expand 2
:expand 3
:expand 4
:expand 5
:expand 6
:expand 7
:expand 8
:expand 9
:expand 10
:expand 11
:expand 12
:expand 13
:expand 14
:expand 15
#object[user$eval926$fn__927 0x76563d26 "user$eval926$fn__927@76563d26"]

This might be especially relevant to core.async, where placing go under doseq is idiomatic, since go is expensive in both expansion time and code size.

user=> (time (eval '(doseq [_ nil] (a/go (doseq [_ nil] (a/go (doseq [_ nil] (a/go))))))))
"Elapsed time: 837.230917 msecs"
nil

It also leads to duplicated reflection warnings from the fully expanded forms, which is how I found this problem.

user=> (doseq [_ nil] (Thread/sleep (identity 1)))
Reflection warning, NO_SOURCE_PATH:1:16 - call to static method sleep on java.lang.Thread can't be resolved (argument types: unknown).
Reflection warning, NO_SOURCE_PATH:1:16 - call to static method sleep on java.lang.Thread can't be resolved (argument types: unknown).
nil

I believe the exponential expansion for doseq was introduced in Clojure 1.1.0 with support for chunked seqs with this commit.

$ clojure -Sdeps '{:deps {org.clojure/clojure {:mvn/version "1.0.0"}}}' 
Downloading: org/clojure/clojure/1.0.0/clojure-1.0.0.pom from central
Downloading: org/clojure/clojure/1.0.0/clojure-1.0.0.jar from central
Clojure 1.0.0-
user=> (defmacro a [] (prn :expand))
#'user/a
user=> (doseq [_ nil] (a))
:expand
nil
user=> ^D
$ clojure -Sdeps '{:deps {org.clojure/clojure {:mvn/version "1.1.0"}}}'
Downloading: org/clojure/clojure/1.1.0/clojure-1.1.0.pom from central
Downloading: org/clojure/clojure/1.1.0/clojure-1.1.0.jar from central
Clojure 1.1.0
user=> (defmacro a [] (prn :expand))
#'user/a
user=> (doseq [_ nil] (a))
:expand
:expand
nil
user=>

At first I wasn't sure if this was hopeless, but I think doseq is fixable fusing the chunked and non-chunked cases like so:

(defmacro doseq
  "Repeatedly executes body (presumably for side-effects) with
  bindings and filtering as provided by \"for\".  Does not retain
  the head of the sequence. Returns nil.
  
  Unlike clojure.core/doseq, does not cause exponential macro expansion
  of expressions in bindings or body."
  [seq-exprs & body]
  (#'clojure.core/assert-args
     (vector? seq-exprs) "a vector for its binding"
     (even? (count seq-exprs)) "an even number of forms in binding vector")
  (let [step (fn step [recform exprs]
               (if-not exprs
                 [true `(do ~@body)]
                 (let [k (first exprs)
                       v (second exprs)]
                   (if (keyword? k)
                     (let [steppair (step recform (nnext exprs))
                           needrec (steppair 0)
                           subform (steppair 1)]
                       (cond
                         (= k :let) [needrec `(let ~v ~subform)]
                         (= k :while) [false `(when ~v
                                                ~subform
                                                ~@(when needrec [recform]))]
                         (= k :when) [false `(if ~v
                                               (do
                                                 ~subform
                                                 ~@(when needrec [recform]))
                                               ~recform)]))
                     (let [seq- (gensym "seq_")
                           chunk- (with-meta (gensym "chunk_")
                                             {:tag 'clojure.lang.IChunk})
                           count- (gensym "count_")
                           i- (gensym "i_")
                           in-chunk- (gensym "in-chunk_")
                           recform `(if ~in-chunk-
                                      (recur ~seq- ~chunk- ~count- (unchecked-inc ~i-))
                                      (recur (next ~seq-) nil 0 0))
                           steppair (step recform (nnext exprs))
                           needrec (steppair 0)
                           subform (steppair 1)]
                       [true
                        `(loop [~seq- (seq ~v), ~chunk- nil,
                                ~count- 0, ~i- 0]
                           (let [~in-chunk- (< ~i- ~count-)
                                 ~seq- (if ~in-chunk- ~seq- (seq ~seq-))]
                             (when (if ~in-chunk- true ~seq-)
                               (let [chunked?# (if ~in-chunk- false (chunked-seq? ~seq-))
                                     ~k (if ~in-chunk-
                                          (.nth ~chunk- ~i-)
                                          (if chunked?# nil (first ~seq-)))]
                                 (if (if ~in-chunk- false chunked?#)
                                   (let [c# (chunk-first ~seq-)]
                                     (recur (chunk-rest ~seq-) c#
                                            (int (count c#)) (int 0)))
                                   (do ~subform
                                       ~@(when needrec [recform])))))))])))))]
    (nth (step nil (seq seq-exprs)) 1)))

Answer selected: defn rejects arity with args vector [&form]

Thu, 22 Aug 2024 20:36:01 +0000

Logged as https://clojure.atlassian.net/browse/CLJ-2874

Commented: Returning the last assigned value from `let` w/o a body

Thu, 14 Mar 2024 00:21:50 +0000

Probably also worth mentioning that the body of a let is wrapped in an implicit do, so (let [x 1 y 2]) is really equivalent to (let [x 1 y 2] (do)) and (do) is going to return nil

Commented: Auto-gensym in recursive macros

Mon, 18 Dec 2023 21:15:14 +0000

this sounds like more a problem with your transpiler?

If you are operating on clojure source and compiling to java, well clojure allows for the same named to be bound in nested static scopes, you you'll have to deal with it via something like alpha conversion.

If you are decompiling jvm byte code to java, the jvm doesn't actually name locals at all, they just get numbered slows. The names are stored as optional debug information, and there is no requirement for uniqueness https://docs.oracle.com/javase/specs/jvms/se11/html/jvms-4.html#jvms-4.7.13

So in either case to faithful capture the semantics (clojure->java, jvm bytecode->java) you need to be able to deal with possibly duplicate names

Commented: Useful macro for output redirection (feature request)

Tue, 12 Sep 2023 20:17:25 +0000

Agree.

P.S.: I cannot send messages shorter than 12 chars lol

Commented: Macro does not work properly

Thu, 03 Aug 2023 21:47:56 +0000

You are correct, thank you! I forgot that Clojure does not have cons cells.

Commented: Why functions which are used inside macro do not evaluate their arguments before executing?

Tue, 01 Aug 2023 22:38:27 +0000

Thank you very much!

Retagged: Using literal map as a dispatch fn in defmulti

Tue, 30 May 2023 16:48:17 +0000

I discovered a minor edge case with the defmulti macro when attempting to use a literal map as the dispatch-fn:
(defmulti frob {:dispatch :map})
According to its arglist, the attr-map? argument is optional, so the map should be parsed as its compulsory dispatch-fn. Instead it is taken to be the var metadata map, and the function is set to nil.
(frob :dispatch) ;; => Execution error (NullPointerException) at scratch/eval68113 (REPL:169). ;; Cannot invoke "clojure.lang.IFn.invoke(Object)" because "this.dispatchFn" is null
Obviously using maps to dispatch a multimethod is not very sensible (amounting to a closed translation map from arg->dispatch value), but it might be a case to consider.

Answered: filter with multiple lists on params

Wed, 22 Mar 2023 19:58:57 +0000

Most preds used with filter take one arg, so this is not commonly needed.

Closed: Bug (?) in with-open macro

Wed, 08 Mar 2023 16:01:55 +0000

I've noticed something strange when macroexpanding (with-open ...)

The (finally ...) part looks something like this:
(finally (. stream clojure.core/close))

While this code does work, it just doesn't feel right to me.
I assume that, if, at some point in the future, the functin clojure.core/close is added to the core namespace, it might break.

Am I right or, maybe, the fact that the method close got namespace-qualified is irrelevant since any functio that goes inside the dot special form invocation (. object method) will be trated as a method name, regardless of its namespace?

Answer selected: Access object field in macro without reflection

Tue, 18 Oct 2022 12:47:40 +0000

The ^ reader does not resolve symbols and accepts symbols and strings as tags (impl).
Consequently, the compiler doesn't look at anything but symbols and strings (impl).

With that being said, there's no warning if you preface MyObj in {:tag MyObj} with a syntax quote.

Answer selected: Would a generalized some-> macro be useful?

Mon, 03 Oct 2022 16:50:39 +0000

Logged as https://clojure.atlassian.net/browse/CLJ-2732

Closed: Hash collisions in case statements try to evaluate the constants

Thu, 13 Jan 2022 22:05:35 +0000

When case statements use hashing and have a hash collision, they embed a condp expression. However, this expression inserts the constants directly, without quoting. If any constants include a symbol, then these will lead to an error.

For example:

(case 'a #{a} 1 :foo 2 a 3)

Leads to: Unable to resolve symbol: a in this context

This can be seen when expanding the macro:

(macroexpand '(case 'a #{a} 1 :foo 2 a 3))
(let* [G__151 (quote a)] (case* G__151 0 1 (throw (java.lang.IllegalArgumentException. (clojure.core/str "No matching clause: " G__151))) {0 [-1640525200 (clojure.core/condp clojure.core/= G__151 #{a} 1 a 3 (throw (java.lang.IllegalArgumentException. (clojure.core/str "No matching clause: " G__151))))], 1 [:foo 2]} :compact :hash-equiv #{0}))

This shows a call to case*. The first and second arguments are 0, 1. When these are used with clojure.core/shift-mask both '#{a} and 'a will hash to 0.

The 5th argument contains a map of hash codes to values, which contains:

{0 [-1640525200 (clojure.core/condp clojure.core/= G__151
                  #{a} 1
                  a 3
                  (throw (java.lang.IllegalArgumentException. (clojure.core/str "No matching clause: " G__151))))],
 1 [:foo 2]}

This condp block contains unquoted values for #{a} and a, so they will incorrectly attempt to match on the value of the current binding for a (if such a binding exists).

Since case will interpret every test-constant as a literal (explicitly stating that they need not be quoted), these values should be quoted when they appear in an embedded Clojure expression like this this condp.

The following is a suggested patch to correct the generated code:

diff --git a/src/clj/clojure/core.clj b/src/clj/clojure/core.clj
index 0dba6fcd..b21d4556 100644
--- a/src/clj/clojure/core.clj
+++ b/src/clj/clojure/core.clj
@@ -6690,7 +6690,7 @@ fails, attempts to require sym's namespace and retries."
                       (next ks) (next vs))
                     m))
         assoc-multi (fn [m h bucket]
-                      (let [testexprs (apply concat bucket)
+                      (let [testexprs (mapcat (fn [kv] [(list 'quote (first kv)) (second kv)]) bucket)
                             expr `(condp = ~expr-sym ~@testexprs ~default)]
                         (assoc m h expr)))
         hmap (reduce1
diff --git a/test/clojure/test_clojure/control.clj b/test/clojure/test_clojure/control.clj
index 92846ad3..f3fe436b 100644
--- a/test/clojure/test_clojure/control.clj
+++ b/test/clojure/test_clojure/control.clj
@@ -421,7 +421,14 @@
          :b 1
          :c -2
          :d 4294967296
-         :d 3))
+         :d 3)
+    (are [result input] (= result (case input
+                                    #{a} :set
+                                    :foo :keyword
+                                    a :symbol))
+         :symbol 'a
+         :keyword :foo
+         :set '#{a}))
   (testing "test warn for hash collision"
     (should-print-err-message
      #"Performance warning, .*:\d+ - hash collision of some case test constants; if selected, those entries will be tested sequentially..*\r?\n"

Commented: Macroexpanding a macro with `fn` crashes with "fn did not conform to spec"

Tue, 11 Jan 2022 23:07:54 +0000

I see thanks again

Commented: Macro defining function

Mon, 30 Aug 2021 19:53:54 +0000

Indeed thanks so much! This is just an exercise from Brave clojure...

Commented: Macro for threading lambda expression

Sat, 03 Jul 2021 14:58:31 +0000

I don't think there's any interest in adding this to Clojure itself. But the cool thing about Clojure and Lisps is we can all have our preferred syntax. :)

Commented: when-seq and if-seq as short-hand macros

Tue, 13 Apr 2021 09:58:06 +0000

The name follows prior naming of `if-some`. Instead of `some?` we use the predicate `seq`.
To follow the behavior of `if-some` the binding should maybe not contain the `seq`-ed object, but the original object. This would also preserve the type information like @eval suggested.

Answered: macroexpansion of macro with anonymous function argument

Sun, 28 Feb 2021 10:04:43 +0000

Try:

(macroexpand-1 '(func-macro (fn [x] x)))

with a normal single quote instead. You don't need the backtick here.

Commented: Capture code as list

Sun, 24 Jan 2021 11:38:00 +0000

I finally have this

    (deftype Call [code])

    (defn call*
      [code]
      (Call. code))

    (def ^:private gen-sym-var
      (let [f (.getDeclaredField clojure.lang.LispReader
                                 "GENSYM_ENV")]
        (.setAccessible f true)
        (.get f nil)))

    (def ^:private syntax-quote
      (let [m (.getDeclaredMethod clojure.lang.LispReader$SyntaxQuoteReader
                                  "syntaxQuote" (into-array Class [Object]))]
        (.setAccessible m true)
        (fn [form]
          (try
            (clojure.lang.Var/pushThreadBindings (hash-map gen-sym-var {}))
            (.invoke m nil (into-array Object [form]))
            (finally
              (clojure.lang.Var/popThreadBindings))))))

    (defmacro call
      [& body]
      (let [ks (set (keys &env))
            myvar (walk/postwalk
                   (fn [sexp]
                     (if (contains? ks sexp)
                       (list 'clojure.core/unquote sexp)
                       sexp))
                   body)]
        `(call* ~(syntax-quote myvar))))

    (defn test
      [p]
      (let [n 1
            ^io.github.fp7.statem.Call foo (call n '(foo bar) (+ n 2) p)]
        (.code foo)))

    (test "")

It works but calls internal methods of clojure. So i think i will stick to my manual quoting/unquoting for the time being. I also tried the same thing with backtick, but that threw some null pointers.

Thanks for your help!

Answer selected: Using atoms inside macro

Sun, 31 May 2020 19:44:01 +0000

Macros are functions that take code and return code. Atoms are stateful objects - there is no way to represent them with identity in code so this is not going to work.

What are you actually trying to do?

Answer selected: binding macro wraps body in try, not do

Tue, 21 Jan 2020 21:59:02 +0000

try has an implicit do in it - what do you want to do that doesn't work?

(binding []
  (println "1")
  (println "2")
  3)
;; 1
;; 2
;;=> 3

Answer selected: Macros and dynamic vars

Sun, 01 Dec 2019 23:09:28 +0000

binding affects runtime. Macros are generally expanded at read time. When you use macroexpand, you are explicitly expanding the macro as part of runtime operations (so the binding affects it).

Answered: clojure.walk.macroexpand-all will not properly expand macros that depend on &env

Wed, 26 Jun 2019 12:00:00 +0000

Reference: https://clojure.atlassian.net/browse/CLJ-2011 (reported by alex+import)

Answered: Macros cannot reliably detect usage of locals

Wed, 26 Jun 2019 12:00:00 +0000

Reference: https://clojure.atlassian.net/browse/CLJ-1997 (reported by gfredericks)