Clojure Q&A - Recent questions tagged macro

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.

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

Sun, 10 Aug 2025 02:40:33 +0000

We can use :let in for to define local variable like this

(for [i (range 5)
      :let [inc-i (inc i)]]
  [i inc-i])
;;=> ([0 1] [1 2] [2 3] [3 4] [4 5])

Otherwise, if we specified :let as first element, it causes an macro expansion error.

(for [:let [range-end 5]
      i (range range-end)
      :let [inc-i (inc i)]]
  [i inc-i])
;;=> Syntax error macroexpanding for at (*cider-scratch*:555:1).
;;   Can't pop empty vector

Of course, in this case, we should have wrapped for in let. However, I'm curious whether making :let available only for second and subsequent elements is intended behavior as part of the public interface.

define several Vars at once in the REPL (convenience fn/macro)

Sat, 16 Mar 2024 21:44:23 +0000

context: I have parsed some extensive XML data from the internet. Now I want to explore/filter/drill down in the REPL.

I have a LazySeq named xs of unknown length and of unknown content. I would like to explore the first few elements of xs at the REPL. For convenience, I would like to def some Vars like so:

(def x1 (nth xs 0 nil))
...
(def x5 (nth xs 4 nil))

This is tedious to type, especially when it needs to be done repeatedly, as I develop my "drill down"-function. Is there a convenience function (or macro) that can do this for me, perhaps like this

(defmany xs "x" 5)
;=> #'my.ns/x1
;=> ...
;=> #'my.ns/x5

I tried to write a function for this. It uses eval and is unsecure (and has other drawbacks as well). So, my questions are:

Does something like this already exist somewhere?
Do I need a macro for this or can it be done with a function? (I am unfamiliar with writing Clojure macros.)
How can this function/macro be defined?

For amusements' sake, here is my attempt:

(defn def-many
  [xs prefix n]
  (map eval
       (for [i (range n)]
            (list 'def
                  (symbol (str prefix (inc i)))
                  (nth xs i nil)))))

(if (nth xs i nil) is a LazySeq or a list then eval will try to interpret it as a function call. This can be tested for and converted to a vector, for example. But yeah, this is not great.)

Macro does not work properly

Thu, 03 Aug 2023 14:08:49 +0000

;;gets a list like (1 + (1 + 2))
;;returns (+ 1 (+ 1 2))
(defmacro infix [expression]
  (letfn [(helper [expression]
               (cond (not (list? expression)) expression
                     (= (count expression) 0) '()
                     (= (count expression) 1)  (recur (first expression))
                     (not (function? (first expression))) (let [a (first expression)
                                                                op (second expression)
                                                                b (nth expression 2)]
                                                                  (recur (cons (list op a b)
                                                                               (drop 3 expression))))
                    :else expression))]
  (helper expression)))

(macroexpand '(infix (1 + 1 * 2 * 4))) ;; => ((+ 1 1) * 2 * 4)
(macroexpand '(infix (((1))))) ;; => 1

The second recur seems to not work (in (not (function? ....)). What is wrong with the code?

Issue with ClojureScript macroexpansion equivalence

Tue, 15 Nov 2022 13:14:49 +0000

In ClojureScript forms can't always be replaced by they macroexpanded forms. This is the case for defrecord and defn on its multi arity version.

 clj -Sdeps '{:deps {org.clojure/clojurescript {:mvn/version "1.11.60"}}}' -M -m cljs.main                                                                          
ClojureScript 1.11.60
                                                                                                                                                   
cljs.user=> (defrecord ARecord [a])                                                                                                                                     
cljs.user/ARecord                                                                                                                                                  

cljs.user=> (macroexpand '(defrecord ARecord [a]))
(let* [] (do (defrecord* ...)))

cljs.user=> (let* [] (do (defrecord* ...)))
WARNING: Wrong number of args (4) passed to ARecord at line 1 <cljs repl>
WARNING: Wrong number of args (4) passed to ARecord at line 1 <cljs repl>
WARNING: Wrong number of args (4) passed to ARecord at line 1 <cljs repl>
WARNING: Wrong number of args (4) passed to ARecord at line 1 <cljs repl>
WARNING: Wrong number of args (4) passed to ARecord at line 1 <cljs repl>
WARNING: Wrong number of args (4) passed to cljs.user/ARecord at line 1 <cljs repl>
WARNING: Wrong number of args (4) passed to cljs.user/ARecord at line 1 <cljs repl>

Same thing happens trying to evaluate the forms resulting from this macroexpansion:

(macroexpand '(defn foo ([a] (foo a 5)) ([a b] (+ a b))))

Why (special-symbol? 'loop) returns false?

Mon, 25 Jul 2022 12:01:36 +0000

Hi, I'm getting started with Clojure and I'm puzzled by the following:

(doc special-symbol?) states "Returns true if s names a special form"
(doc loop) states "clojure.core/loop … Special Form: Evaluates the…"
But (special-symbol? 'loop) returns false.

Since (source loop) reveals it is a (defmacro …, I wonder if in the docs loop should be called a macro rather than a special form?

Also because (special-form? 'def) returns true, and def has no source, i.e. is not defined as a macro.

How do you access namespace values in a macro?

Mon, 23 Aug 2021 15:58:29 +0000

I'm working in clojurescript, where ns-interns is a macro.

I'm trying to write a macro that gets information about the internal bindings in a namespace, but I'm not able to manipulate the bindings at compile time.

(defmacro my-macro [namespace]
   (let [mappings (ns-interns namespace)]
           ; do stuff
       ))

(my-macro 'mylib.hi)

The trouble is that the above fails because the ns-interns macro think it's processing the symbol namespace, and not the namespace I pass into my-macro.

I can try

[mappings `(ns-interns ~namespace)]

, but then I can't expand the macro at compile-time into a map that I can use to generate code -- the only thing I can do is "print" it in the generated code. I tried using macroexpand and macroexpand-all, but they did not work for me -- I couldn't use them to get the results of ns-interns for use in my macro.

However, macros can be expanded, since the below will work if I hard-code the namespace symbol. The trouble comes because I want to pass the outer macro's argument into an inner macro. What's the right way to solve approach this, where I want to get and manipulate the vars of a namespace at compile-time in Clojurescript?

(defmacro my-macro [namespace]
   (let [mappings (ns-interns 'mylib.hi)]
     ; do stuff
   )
)

Macro defining function

Fri, 06 Aug 2021 07:36:15 +0000

I am trying to do an exercise in Brave Clojure (chapter 8 exercise 3). I have simplified it to get to the bottom of my issue.

Consider this setup:

(def person {:first-name "Louis"
             :last-name "Bourvil"
             :age 32
             :city "Nantes"})

I'd like to be able to the following:

(create-func c-age :age)
(c-age person)

I know this works:

(defmacro create-func [func-name attr] `(def ~func-name ~attr))

But I was trying to do with a function and can't understand why this does not work:

(defmacro create-func [func-name attr] `(defn ~func-name [person] (~attr person)))
(create-func c-age :age)
; Syntax error macroexpanding clojure.core/defn at (REPL: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

(from the repl)

Do you see where I'm wrong?

Macro for threading lambda expression

Fri, 02 Jul 2021 16:53:46 +0000

It is common to have lambda functions with one argument for things like map, filter, find, etc.

I think could be usefull a macro that do something like (fn-> :value inc (> 1)) which would be equivalent of #(-> % :value inc (> 1))

Something like

(defmacro fn->
  [& forms]
  `(fn [x#] (-> x# ~@forms)))
(defmacro fn->>
  [& forms]
  `(fn [x#] (->> x# ~@forms)))

I see this a very useful for readability if in the core library. wdyt?

How should I correctly detect a protocol symbol in a macro targeting CLJS?

Fri, 25 Jun 2021 00:03:30 +0000

Up through Clojurescript 1.10.844, I could reliably tell whether a symbol sym (at macro-expansion time) referred to a protocol by examining the following:

(:protocol-symbol (cljs.analyzer.api/resolve &env sym))

As of the commit for CLJS-3276, this no longer works in my code. As far as I can tell, defprotocol still attaches this data, and cljs.core still uses this method internally. Is there a better / supported way to detect whether a symbol refers to a protocol? I'm very much hoping that this behavior is reintroduced, or else that there is some other reliable method.

Is the defn spec overly restrictive?

Tue, 18 May 2021 10:21:51 +0000

It seems like it should be possible to use a macro for generating a attribute map for defn but it appears as if the defn spec requires a literal map. See example below, which makes the spec fail.

   (defmacro example [f output input]
     `{:test (fn [] (is (= (~f ~input) ~output)))})

   (defn tails
     (example tails
              [1 2 3 4]
              '([1 2 3 4] (2 3 4) (3 4) (4)))
     [coll]
     (take-while some? (iterate next coll)))

 Call to clojure.core/defn did not conform to spec.
       #:clojure.spec.alpha{:problems
                            ({:path [:fn-tail :arity-1 :params],
                              :pred clojure.core/vector?,
                              :val
                              (example
                               tails
                               [1 2 3 4]
                               '([1 2 3 4] (2 3 4) (3 4) (4))),
                              :via
                              [:clojure.core.specs.alpha/defn-args
                               :clojure.core.specs.alpha/params+body
                               :clojure.core.specs.alpha/param-list
                               :clojure.core.specs.alpha/param-list],
                              :in [1]}
                             {:path [:fn-tail :arity-n :bodies :params],
                              :pred clojure.core/vector?,
                              :val example,
                              :via
                              [:clojure.core.specs.alpha/defn-args
                               :clojure.core.specs.alpha/params+body
                               :clojure.core.specs.alpha/params+body
                               :clojure.core.specs.alpha/params+body
                               :clojure.core.specs.alpha/param-list
                               :clojure.core.specs.alpha/param-list],
                              :in [1 0]}),
                            :spec
                            #object[clojure.spec.alpha$regex_spec_impl$reify__2510 0x643aeb02 "clojure.spec.alpha$regex_spec_impl$reify__2510@643aeb02"],
                            :value
                            (tails
                             (example tails [1 2 3 4] '([1 2 3 4] (2 3 4) (3 4) (4)))
                             [coll]
                             (take-while some? (iterate next coll))),
                            :args
                            (tails
                             (example tails [1 2 3 4] '([1 2 3 4] (2 3 4) (3 4) (4)))
                             [coll]
                             (take-while some? (iterate next coll)))}
                     alpha.clj:  712  clojure.spec.alpha/macroexpand-check
                     alpha.clj:  704  clojure.spec.alpha/macroexpand-check
                      AFn.java:  156  clojure.lang.AFn/applyToHelper
                      AFn.java:  144  clojure.lang.AFn/applyTo
                      Var.java:  705  clojure.lang.Var/applyTo
                 Compiler.java: 6974  clojure.lang.Compiler/checkSpecs
                 Compiler.java: 6992  clojure.lang.Compiler/macroexpand1
                 Compiler.java: 7079  clojure.lang.Compiler/macroexpand
                 Compiler.java: 7165  clojure.lang.Compiler/eval
                 Compiler.java: 7136  clojure.lang.Compiler/eval
                      core.clj: 3202  clojure.core/eval
                      core.clj: 3198  clojure.core/eval
        interruptible_eval.clj:   87  nrepl.middleware.interruptible-eval/evaluate/fn/fn
                      AFn.java:  152  clojure.lang.AFn/applyToHelper
                      AFn.java:  144  clojure.lang.AFn/applyTo
                      core.clj:  667  clojure.core/apply
                      core.clj: 1977  clojure.core/with-bindings*
                      core.clj: 1977  clojure.core/with-bindings*
                   RestFn.java:  425  clojure.lang.RestFn/invoke
        interruptible_eval.clj:   87  nrepl.middleware.interruptible-eval/evaluate/fn
                      main.clj:  437  clojure.main/repl/read-eval-print/fn
                      main.clj:  437  clojure.main/repl/read-eval-print
                      main.clj:  458  clojure.main/repl/fn
                      main.clj:  458  clojure.main/repl
                      main.clj:  368  clojure.main/repl
                   RestFn.java:  137  clojure.lang.RestFn/applyTo
                      core.clj:  667  clojure.core/apply
                      core.clj:  662  clojure.core/apply
                    regrow.clj:   20  refactor-nrepl.ns.slam.hound.regrow/wrap-clojure-repl/fn
                   RestFn.java: 1523  clojure.lang.RestFn/invoke
        interruptible_eval.clj:   84  nrepl.middleware.interruptible-eval/evaluate
        interruptible_eval.clj:   56  nrepl.middleware.interruptible-eval/evaluate
        interruptible_eval.clj:  152  nrepl.middleware.interruptible-eval/interruptible-eval/fn/fn
                      AFn.java:   22  clojure.lang.AFn/run
                   session.clj:  202  nrepl.middleware.session/session-exec/main-loop/fn
                   session.clj:  201  nrepl.middleware.session/session-exec/main-loop
                      AFn.java:   22  clojure.lang.AFn/run
                   Thread.java:  829  java.lang.Thread/run

macroexpansion of macro with anonymous function argument

Sun, 28 Feb 2021 09:10:19 +0000

Hi!

I have following synthetic macro receiving function expression as argument:

(defmacro func-macro [f]
  `(def x ~f))

Macroexpansion gives me:

( macroexpand-1 `(func-macro (fn [x] x)))
  ->
  (def runtime.repl/x (clojure.core/fn [runtime.repl/x] runtime.repl/x))

If i execute this code form in REPL then i ll get an error because function has namespace qualified symbol runtime.repl/x as argument.

(runtime.repl/x) - failed: Extra input at: [:fn-tail :arity-1 :params] spec: :clojure.core.specs.alpha/param-list
runtime.repl/x - failed: vector? at: [:fn-tail :arity-n :params] spec: :clojure.core.specs.alpha/param-list

But if i am calling this macro in REPL then all things work!

( (func-macro (fn [x] x)) 100)
    ->
    100

Why runtime.repl/x is OK for function definition if i am calling macro in REPL?

Thanks!

Andray

case has incorrect + difficult-to-comprehend behavior matching 'quote on Clojure 1.10.0

Sun, 26 Jul 2020 21:18:09 +0000

I'm implementing a small Lisp interpreter, which led me to discover this bug in the implementation of case:

(case "s"
  'quote "quote"
  "default")

;; Syntax error macroexpanding case at (org:localhost:56082(clj)*:131:16).
;; Duplicate case test constant: quote

I thought this might be a good workaround:

(case 'quote
  (symbol "quote") "quote"
  "default")
;; => "default"

This doesn't work, it returns "default".

Strangely, even though (symbol quote) would be invalid, since quote is not bound, THIS does "work" by returning "quote":

(case 'quote
  (symbol quote) "quote"
  "default")
;; => "quote"

Very weird. And look at this. Let's try a case of 'face. What will it return?

(case 'quote
  'face "face"
  "default")
;; => "face"

It matches 'quote!

Actually anything quoted matches:

(case 'quote
  (quote 123) "123"
  "default")
;; => "123"

Hopefully this will be enough for this to make sense to someone with knowledge of case's macroexpansion.

Cheers!

cljs.analyzer macroexpand doesn't work

Tue, 21 Jul 2020 16:13:21 +0000

(ns user
  (:require [cljs.analyzer :as analyzer]))

(let [ns-env (assoc-in (analyzer/empty-env) [:ns [:name]] 'cljs.user)]
  (analyzer/macroexpand-1 ns-env `(defn ~'foo [~'x] ~'x)))
;; (clojure.core/defn foo [x] x)

(macroexpand-1 `(defn ~'foo [~'x] ~'x))
;; (def foo (clojure.core/fn ([x] x)))