Clojure Q&A - Recent questions tagged fn

Destructuring {:as opts} unexpected behaviour with seq

Sat, 04 Apr 2026 23:50:39 +0000

Hi,

I found out something weird in some old code, where I wanted to pass the first map in a sequence and by mistake the code was working while actually passing the sequence itself!

After digging to make sense of this, I found out it has to do with the {:as opts} destructuring.

Here's some code:

;; even if something is assigned sequential vs associative
;; the `:as` is transparent
(let [[:as opts] {1 2 3 4}]
  opts)
#_=> {1 2, 3 4}
(let [{:as opts} [1 2 3 4]]
  opts)
#_=> [1 2 3 4]
;; however with a seq it's returned as a map
(let [{:as opts} (seq [1 2 3 4])]
  opts)
#_=> {1 2, 3 4}

;; and it only gets weirder!
(let [{:as opts} (seq [{:k :v}])]
  opts)
#_=> {:k :v}
(let [{:as opts} (seq [{:k1 :v1} {:k2 :v2}])]
  opts)
#_=> {{:k1 :v1} {:k2 :v2}}
(let [{:as opts} (seq [{:k1 :v1} {:k2 :v2} {:k3 :v3}])]
  opts)
#_=> {{:k1 :v1} {:k2 :v2}, :k3 :v3}
(let [{:as opts} (seq [{:k1 :v1} {:k2 :v2} :not-a-map])]
  opts)
;; java.lang.IllegalArgumentException: Don't know how to create ISeq from: clojure.lang.Keyword
(let [{:as opts} (seq [1 2 3])]
  opts)
;; java.lang.IllegalArgumentException: Don't know how to create ISeq from: java.lang.Long

In my case I didn't realize my code was wrong because {:as opts} {:k :v} is the same as {:as opts} (seq [{:k :v}]).

To me this is behaviour I would expect closer to & {:as opts} rather than just plain map destructuring {:as opts}. Maybe both behaviours should be separated?

I think this should be tackled either by
1. make :as transparent regardless of what comes in to always bind
2. throw an error earlier when it's not of the expected destructuring
3. Document this very unexpected edge case in https://clojure.org/reference/special_forms#associative-destructuring
4. Separate the keyword arguments use case from plain map destructuring? (Assuming both are now mixed together)

A function with metadata is slower than it could be

Mon, 03 Mar 2025 07:20:38 +0000

I found that with-meta applied to a function returns an instance of RestFn.
However, I know that invoking a function through applyTo is much slower than through invoke.
The benchmarks in :thread: confirm this.

Is it a problem that a function with metadata is slower than it could be?

If so, I could propose a solution - to proxy all methods like invoke to the original function, not just applyTo.

https://github.com/clojure/clojure/blob/master/src/jvm/clojure/lang/AFunction.java#L31-L33

(require '[criterium.core :as c])

(defn f [x]
  x)

(c/quick-bench
    (f 1))
;; Execution time mean : 1,642094 ns

(defn wrapper [f]
  (fn [y]
    (f y)))

(let [f' (wrapper f)]
  (c/quick-bench (f' 1)))
;; Execution time mean : 5,016630 ns

(let [f'' (with-meta f {:foo :bar})]
  (c/quick-bench (f'' 1)))
;; Execution time mean : 31,332965 ns

(defn wrapper' [f]
  (fn [& args]
    (apply f args)))

(let [f''' (wrapper' f)]
  (c/quick-bench (f''' 1)))
;; Execution time mean : 41,983970 ns

Additional links:
- https://clojurians.slack.com/archives/C03S1KBA2/p1740750168290999
- https://github.com/camsaul/methodical/pull/150

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

Tue, 11 Jan 2022 08:29:50 +0000

The following code crashes:

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

(macroexpand '(m))

The error is:

Call to clojure.core/fn did not conform to spec
[...]
:reason "Extra input"

The following code does not crash and works as expected:

(defmacro m []
  `(asdfasdf [x]))

(macroexpand '(m))

How does the first snippet crash when the macro should just be returning a quoted piece of code? Why does it run fn at all?

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?