Clojure Q&A - Recent questions tagged destructuring

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)

Consider postponing setting the default values of destructured map keys that might rely on other keys

Fri, 21 Mar 2025 10:04:09 +0000

It's a rather frequent question where somebody gets a syntax error when trying to use something like {:keys [a b ...] :or {b a}}. The most recent instance: https://clojurians.slack.com/archives/C03S1KBA2/p1742549907988549

The error is as user-unfriendly as it gets and the behavior is also counter-intuitive if you don't happen to know the insides of destructuring and maps.

Perhaps it would make sense to alter the destructuring impl for when the default value in :or is not a primitive. So instead of being expanded to b (get map__1 :b a) it's expanded to b (get map__1 :b ::not-found) with a subsequent rebinding to b (if (identical? b ::not-found) a b) after all the other keys have already been extracted.

ClojureScript: Destructuring two keys differing only on dash vs underscore doesn't work

Mon, 03 Feb 2025 16:09:41 +0000

When i try to destructure a key, supporting both kebab and snake case I run in to trouble:

Sometimes both symbols pick up the same value:

(let [{:keys [foo-bar foo_bar] :as m} {:foo_bar 42}]
  [foo-bar (:foo-bar m) foo_bar (:foo_bar m)])
;;=> [42 nil 42 42]

Other times one symbol overshadows the other one:

(let [{:keys [foo-bar foo_bar
              a b c d e f g] :as m} {:foo_bar 42}]
  [foo-bar (:foo-bar m) foo_bar (:foo_bar m)])
;;=> [nil nil nil 42]

At least that's what I think is going on there: foo-bar doesn't exist and gets the value nil, overshadowing the symbol foo_bar for which the value exists.

This is supposedly a known limitation in ClojureScript, but I couldn't find it in the issue tracker. Nor does it seem like ChatGPT knows about it. Maybe it helps a bit to have it visible here for bots and humans alike.

destructuring corner case: [& {:as key-vals}]

Wed, 03 Jul 2024 11:49:12 +0000

I don't find the behavior of the following expression documented.
Can someone either point me to the documentation, or I request
that the documentation be updated to warn about this caveat.

https://clojure.org/guides/destructuring

((fn [& {:as key-vals}] key-vals) :a 100 :b 200) ;; case 1
(let [[& {:as key-vals}] '(:a 100 :b 200)] key-vals) ;; case 2

These both evaluate to a map {:a 100 :b 200). However, the following evaluate to nil rather than an empty map.

((fn [& {:as key-vals}] key-vals) ) ;; case 3
(let [[& {:as key-vals}] ()] key-vals)  ;; case 4

The tag https://clojure.org/guides/destructuring#_keyword_arguments does not exactly say what happens in these cases; however, intuitively I'd expect that key-vals should be a map in all 4 cases. Instead it is a map in the first to cases, but is nil in cases 3 and 4. I'd expect cases 3 and 4 to each evaluate to an empty map.

Wrong line number reported for exceptions thrown by code generated by destructuring

Sat, 06 Jan 2024 10:56:33 +0000

Put anywhere in bad_line_number.clj, run with clj -J-Dclojure.main.report=stderr -Sdeps '{:paths ["."]}' -M -m bad-line-number from the same dir.

(ns bad-line-number)

(defn returns-a-tuple []
  [{1 2} :wrapped])

(defn should-also-return-a-tuple-but-doesnt [data]
  {data :unwrapped})

(defn -main []
  (let [[a fmt] (returns-a-tuple)
        data
        (try
          (should-also-return-a-tuple-but-doesnt a)
          (catch Throwable _
            (println "Unable to create a map")
            [3 4]))

        [x y]
        (case fmt
          :wrapped data
          :unwrapped [data nil])]
    [x y]))

Running that code results in

{:clojure.main/message
 "Execution error (UnsupportedOperationException) at bad-line-number/-main (bad_line_number.clj:10).\nnth not supported on this type: PersistentArrayMap\n",
 :clojure.main/triage
 {:clojure.error/class java.lang.UnsupportedOperationException,
  :clojure.error/line 10,
  :clojure.error/cause
  "nth not supported on this type: PersistentArrayMap",
  :clojure.error/symbol bad-line-number/-main,
  :clojure.error/source "bad_line_number.clj",
  :clojure.error/phase :execution},
 :clojure.main/trace
 {:via
  [{:type java.lang.UnsupportedOperationException,
    :message "nth not supported on this type: PersistentArrayMap",
    :at [clojure.lang.RT nthFrom "RT.java" 992]}],
  :trace
  [[clojure.lang.RT nthFrom "RT.java" 992]
   [clojure.lang.RT nth "RT.java" 940]
   [bad_line_number$_main invokeStatic "bad_line_number.clj" 10]
   [bad_line_number$_main invoke "bad_line_number.clj" 9]
   [clojure.lang.AFn applyToHelper "AFn.java" 152]
   [clojure.lang.AFn applyTo "AFn.java" 144]
   [clojure.lang.Var applyTo "Var.java" 705]
   [clojure.core$apply invokeStatic "core.clj" 667]
   [clojure.main$main_opt invokeStatic "main.clj" 514]
   [clojure.main$main_opt invoke "main.clj" 510]
   [clojure.main$main invokeStatic "main.clj" 664]
   [clojure.main$main doInvoke "main.clj" 616]
   [clojure.lang.RestFn applyTo "RestFn.java" 137]
   [clojure.lang.Var applyTo "Var.java" 705]
   [clojure.main main "main.java" 40]],
  :cause "nth not supported on this type: PersistentArrayMap"}}

Execution error (UnsupportedOperationException) at bad-line-number/-main (bad_line_number.clj:10).
nth not supported on this type: PersistentArrayMap

As you can see, it refers to line 10, which has (let [[a fmt] (returns-a-tuple), so naturally the first line of thinking is "returns-a-tuple somehow returns a map, and that's what I need to investigate".
Just spent a few hours chasing that goose when it's actually should-also-return-a-tuple-but-doesnt that's to blame.

:or destructuring doesn't update object

Mon, 07 Aug 2023 20:11:20 +0000

This is related to a number of other asks/jira tickets but I haven't found one for this specifically.

Because :or is destructured into not-found values of the get calls for the destructured keys/symbols/etc, if you bind an object with :as and include defaults in :or, the object won't have the defaults:

(defn example [{:keys [a b]
                :or {a 1 b 2}
                :as opts}]
  (println a b opts))

(example {:a 5})
;=> 5 2 {:a 5}

This has led to subtle bugs in our codebase where we expected the defaults to exist and then they didn't, or we used {:pre [some-pred]} to check an invariant which was violated when we modified the function to use :as in addition to the specific values.

To merge them, you'd want to build the map and then opts (conj defaults-map opts), but that requires iterating over the keys/syms/strs a second time, selecting only the names in the :or map and requires creating another map, or maybe calling assoc repeatedly.

I think it's doable, it would just be a little annoying to write.

Map destructuring works on singleton lists

Thu, 10 Nov 2022 08:15:43 +0000

(let [{x :x} '({:x "foo"})] x)
;; => "foo"

Has middle of sequence &rest destructuring been considered?

Mon, 20 Jun 2022 13:23:18 +0000

Currently, Clojure allows for destructuring patterns that contain &rest arguments:

user=> (let [[a b & c] (range 5)] [a b c])
[0 1 (2 3 4)]

Python allows for the same, but also for placing the so-called catch-all in the front and middle position as well (PEP description):

>>> a, *b, c = range(5)
>>> a
0
>>> c
4
>>> b
[1, 2, 3]

Has similar been considered for Clojure? Could look like this:

user=> (let [[a & b c] (range 5)] [a b c])
[0 (1 2 3) 4]

I feel like this would be doable with how the core functions destructure currently works, but it’s possible I don’t know some subtlety.

Rest for map destructuring

Mon, 25 Oct 2021 10:04:49 +0000

I suggest adding :rest key for map destructuring syntax.
How do you think the following feature would be useful?

(let [m {:a 1 :b 2}
      {:keys [a] :rest r} m]
  (assert (= {:b 2} r)))

Or even like the rest of an array [a b & r]:

(let [m {:a 1 :b 2}
      {:keys [a]
       :& r} m]
  (assert (= {:b 2} r)))

Using (s/or) without destructuring

Sun, 22 Nov 2020 19:20:02 +0000

I have a sequence of characters, and am trying to use (s/cat ...) with (s/or) in order to conform the sequence.

The input could look something like [0 1 2 3] or [\a \b \c \d] and I am trying to use this spec.

(s/conform (s/cat :top (s/or :nums (s/+ #{0 1 2 3 4})
                             :letters (s/+ #{\a \b \c \d})
                  ... more stuff))
           [0 1 2 3])
=> :clojure.spec.alpha/invalid

Not using the (s/or) works if I choose one of :nums or :letters.

(s/conform (s/cat :first-set (s/+ #{0 1 2 3 4}))
           [0 1 2 3])
=> {:first-set [0 1 2 3]}

The initial example works if the entire sequence is wrapped in another vec, but this isn't what I want.

(s/conform (s/cat :first-set (s/or :nums (s/+ #{0 1 2 3 4})
                                   :letters (s/+ #{\a \b \c \d})))
           [[0 1 2 3]])
=> {:first-set [:nums [0 1 2 3]]}

Using (or ...) also seems to only work inside (s/keys). I'm guessing it's because the (or always takes the first spec because it's not falsy.

(s/conform (s/cat :first-set (or (s/+ #{0 1 2 3 4})
                                 (s/+ #{\a \b \c \d})))
           [0 1 2 3])
=> {:first-set [0 1 2 3]}

(s/conform (s/cat :first-set (or (s/+ #{0 1 2 3 4})
                                 (s/+ #{\a \b \c \d})))
           [\a \b \c])
=> :clojure.spec.alpha/invalid

This is what I want to happen.

(s/conform (s/cat :first-set (s/something-here (s/+ #{0 1 2 3 4})
                                               (s/+ #{\a \b \c \d})))
           [0 1 2 3])
=> {:first-set [0 1 2 3]}

(s/conform (s/cat :first-set (s/something-here (s/+ #{0 1 2 3 4})
                                               (s/+ #{\a \b \c \d})))
           [\a \b \c])
=> {:first-set [\a \b \c]}

I'm wondering what to do here.

Order of key destructuring in :or

Mon, 02 Nov 2020 09:16:39 +0000

I was under the assumption that {:keys [a b c d]} was destructured in the order of a->b->c->d which is proven below

haystack.core=> (clojure.pprint/pprint (destructure '[{:keys [a b c d] :as options} {}]))
[map__14131
 {}
 map__14131
 (if
  (clojure.core/seq? map__14131)
  (clojure.lang.PersistentHashMap/create (clojure.core/seq map__14131))
  map__14131)
 options
 map__14131
 a
 (clojure.core/get map__14131 :a)
 b
 (clojure.core/get map__14131 :b)
 c
 (clojure.core/get map__14131 :c)
 d
 (clojure.core/get map__14131 :d)]
nil

however, when the keys vector has elements > 10, the order changes all of a sudden

haystack.core=> (clojure.pprint/pprint (destructure '[{:keys [a b c d e f g h i j] :as options} {}]))
[map__14137
 {}
 map__14137
 (if
  (clojure.core/seq? map__14137)
  (clojure.lang.PersistentHashMap/create (clojure.core/seq map__14137))
  map__14137)
 options
 map__14137
 i
 (clojure.core/get map__14137 :i)
 a
 (clojure.core/get map__14137 :a)
 e
 (clojure.core/get map__14137 :e)
 c
 (clojure.core/get map__14137 :c)
 g
 (clojure.core/get map__14137 :g)
 j
 (clojure.core/get map__14137 :j)
 h
 (clojure.core/get map__14137 :h)
 b
 (clojure.core/get map__14137 :b)
 d
 (clojure.core/get map__14137 :d)
 f
 (clojure.core/get map__14137 :f)]
nil

I couldn't find anything in the destructure source code

Has the destructuring spec changed since 1.8.0?

Fri, 25 Sep 2020 15:24:01 +0000

1.8.0:

clj-rcon-test.core=> (defn- hi [as-codec & {:keys [offset] :or {:offset 0}}]
                #_=>   (println "hi"))
#'clj-rcon-test.core/hi

1.10.0:

clj-rcon-test.core=> (defn- hi [as-codec & {:keys [offset] :or {:offset 0}}]
                #_=>   (println "hi"))
Syntax error macroexpanding clojure.core/defn- at (form-init17556793069765460591.clj:1:1).
:offset - failed: simple-symbol? at: [:fn-tail :arity-1 :params :var-params :var-form :map-destructure :or 0] spec: :clojure.core.specs.alpha/or
{:keys [offset], :or {:offset 0}} - failed: simple-symbol? at: [:fn-tail :arity-1 :params :var-params :var-form :local-symbol] spec: :clojure.core.specs.alpha/local-name
{:keys [offset], :or {:offset 0}} - failed: vector? at: [:fn-tail :arity-1 :params :var-params :var-form :seq-destructure] spec: :clojure.core.specs.alpha/seq-binding-form
as-codec - failed: vector? at: [:fn-tail :arity-n :bodies :params] spec: :clojure.core.specs.alpha/param-list

clj-rcon-test.core=>

For context this is what I'm trying to troubleshoot: https://github.com/gpittarelli/clj-rcon/blob/master/src/clj_rcon/codecs.clj#L6

Missing error on silly destructuring mistake

Wed, 09 Sep 2020 07:32:08 +0000

I happened to define a function like this

(defn foo [{:keys [bar :as lol]}] lol)

Obviously the destructuring is wrong, it should have been

(defn foo [{:keys [bar] :as lol}] lol)

My question is then, should this destructuring error be caught by the specs for destructuring?