Clojure Q&A - Recent questions and answers in Macros

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

Sat, 21 Mar 2026 13:49:43 +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.

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

Mon, 11 Aug 2025 01:09:48 +0000

Seems like it is working as intended per the docstring.

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

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

Logged as https://clojure.atlassian.net/browse/CLJ-2900, happy to see a patch if you make one.

Answered: defn rejects arity with args vector [&form]

Wed, 21 Aug 2024 15:05:58 +0000

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

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

Sat, 10 Aug 2024 18:39:14 +0000

+1 for this.

This is when you want the conditional expression to return a useful value instead of true/false and use that value in the body as is.
If there are multiple conditions, the if-let is nested, but being able to describe it flatly is considered to contribute to readability.

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

Wed, 13 Mar 2024 23:46:15 +0000

This behavior is expected, as with any other form that evaluates a body. The return value is the final expression in the body. If you want to return one of your bindings, you must do so explicitly. This is even shown in the example in the official Clojure documentation about the let special form, at https://clojure.org/reference/special_forms#let

If you are using a good linter like clj-kondo, it will warn you if you have any bindings that you have not done anything with.

Changing this would be quite jarring for people who are used to LISPs, and make let inconsistent with other forms in Clojure as well.

Answered: Useful macro for output redirection (feature request)

Mon, 04 Sep 2023 14:59:22 +0000

A counterpoint: (with-err-out (do-stuff)) is hardly shorter or more readable than (binding [*out* *err*] (do-stuff)).

Answered: Macro does not work properly

Thu, 03 Aug 2023 14:18:33 +0000

I think there are probably several predicate related issues here. For the first condition, I think you'll want to use something broader than list? (which is just for list collections) and instead maybe use something that includes seqs like sequential?. I'm not sure what function? is, but in your case those will be symbols so symbol? should work. I suspect that's your current issue because that's the branch you're not seeing. You might want to add a fallthrough :else branch in the cond to tell you when it doesn't match.

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

Tue, 01 Aug 2023 21:53:22 +0000

Both the internal and external function are behaving the same - they receive a list.

The evaluation happens prior to invocation (so it's not "the function" that is doing the evaluation but the call site invoking it).

Here, the argument to func and helper is the symbol expr. Symbols are evaluated by resolving that "name" to a value in the current lexical context, here defined in the defmacro parameters. It resolves to a list (+ 1 2). That list is passed to the function. Evaluating that list would require evaluating the argument twice!

Macro expansion is not evaluation and the arguments are not evaluated.

Answered: Using literal map as a dispatch fn in defmulti

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

Filed as https://clojure.atlassian.net/browse/CLJ-2782

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.

Answered: Access object field in macro without reflection

Tue, 18 Oct 2022 11:27:28 +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.

Answered: Would a generalized some-> macro be useful?

Mon, 03 Oct 2022 16:24:21 +0000

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

Answered: Auto-gensym in recursive macros

Fri, 24 Jun 2022 21:40:26 +0000

auto gensyming does the gensym at read time, not at macroexpand time.

in order for auto gensym to gensym at macroexpand time, the syntax quote reader could be altered to produce a let binding.

currently:
user=> (read-string "`(x#)") (clojure.core/seq (clojure.core/concat (clojure.core/list (quote x__9__auto__)))) user=>

would become:
user=> (read-string "`(x#)") (clojure.core/let [foo (gensym 'x)] (clojure.core/seq (clojure.core/concat (clojure.core/list foo))) user=>

a consequence of that change would be a macro like clojure.core/and (picking a commonly used macro that uses gensyms at random) would gensym new symbols everytime it was expanded instead of once when the implementation is read. That might be fine? gensyming should be fast, the new symbols are used when compiling then forgotten about, the counter for gensym names can count really high.

Answered: Bug (?) in with-open macro

Tue, 11 Jan 2022 14:38:40 +0000

Yep, should be cleaner in the expansion (but ignored during compilation). Added ticket and patch:

https://clojure.atlassian.net/browse/CLJ-2683

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

Tue, 11 Jan 2022 14:20:54 +0000

Not sure what version of Clojure or editor you're using but Clojure 1.10.3 gives more useful output in the standard repl:

user=> (macroexpand '(m))
Syntax error macroexpanding clojure.core/fn at (REPL:1:1).
(user/x) - failed: Extra input at: [:fn-tail :arity-1 :params] spec: :clojure.core.specs.alpha/param-list
user/x - failed: vector? at: [:fn-tail :arity-n :params] spec: :clojure.core.specs.alpha/param-list

As you can see it is not running your code but (recursively) macroexpanding when the problem is encountered. The first expansion will become:

(clojure.core/fn [user/x])

clojure.core/fn is itself a macro that is expanded. During that expansion, the fn macro is checked against the fn spec (this is on by default for macros). The spec finds user/x and sees it as "extra input" in the :params because it does not conform to any expected parameter form (unqualified symbols usually, but also all recursive destructuring forms). Really, the problem here is user/x instead of x.

You can fix this with:

(defmacro m []
  `(fn [~'x]))

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

Tue, 14 Dec 2021 14:58:45 +0000

Created a new ticket at https://clojure.atlassian.net/browse/CLJ-2679

Answered: Macro defining function

Fri, 06 Aug 2021 11:43:21 +0000

(defmacro create-func [func-name attr] `(defn ~func-name [person] (~attr person)))
(create-func c-age :age)

When you write this, it will expand to

(defn c-age [user/person] (:age user/person))
Syntax error macroexpanding clojure.core/defn at (/tmp/form-init14482279258588584188.clj:1:1).
user/person - failed: vector? at: [:fn-tail :arity-n :bodies :params] spec: :clojure.core.specs.alpha/param-list
(user/person) - failed: Extra input at: [:fn-tail :arity-1 :params] spec: :clojure.core.specs.alpha/param-list

To avoid this, you should write

(defmacro create-func [func-name attr] `(defn ~func-name [person#] (~attr person#)))

or use another way to do not use qualified symbols in parameter name.

create macros for "getter" is a antipattern in clojure.
if you want to access a field, just access it.
also, def-macros usually can be written as a function

(def c-age (im-not-a-macro :age))

Answered: Macro for threading lambda expression

Fri, 02 Jul 2021 21:03:39 +0000

Isn't it shorter to just put the # at the front of your thread expression?

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

Sat, 10 Apr 2021 20:22:46 +0000

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

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.

Answered: Capture code as list

Tue, 19 Jan 2021 20:00:03 +0000

My initial thought is that backtick would help a bit. Interesting question.

Answered: Using atoms inside macro

Sun, 31 May 2020 04:52:50 +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?

Answered: binding macro wraps body in try, not do

Tue, 21 Jan 2020 20:18:10 +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

Answered: Macros and dynamic vars

Fri, 29 Nov 2019 21:31:04 +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: 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)

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

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

Reference: https://clojure.atlassian.net/browse/CLJ-1534 (reported by kul)

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)