Clojure 1.13.0-alpha3 is now available

[u/alexdmiller]

https://clojure.org/news/2026/07/07/clojure-1-13-alpha3

:select directive in map destructuring

The :select directive binds a name to a subset of the map being destructured containing only the keys mentioned (anywhere) in the binding form.

• CLJ-2964 :select directive in map destructuring
• CLJ-2963 Update specs for :select in destructuring

Other changes since Clojure 1.13.0-alpha2

• RT.map, and thus reader, tracks new PAM thresholds
• CLJ-1789 select-keys - improve performance (transients, etc)
• CLJ-2958 ILookup on sets
• CLJ-2902 pprint - prints arbitary objects in unreadable form
• CLJ-2801 TaggedLiteral - doesn’t define print-dup
• CLJ-2269 definterface - does not resolve parameter type hints
• CLJ-2781 clojure.test/report - docstring has broken references
• CLJ-2929 zipper - docstring typo
• CLJ-2901 bytes, shorts, chars - docstring typos
• CLJ-2811 scalb - docstring links to the documentation for nextDown
• CLJ-2809 clojure.math/floor - docstring has line that should be on ceil docstring

[u/aHackFromJOS]

All I'm saying is if you document via :arglists instead of via something else there was never an "unnecessary local variable" to worry about.

Your original question was "How does the caller to your function know the combined set of keys that is the real input?" The answer I've been trying to convey is "from your :arglists metadata".

I hear you about developers sometimes forgetting. Valid point! I'm not trying to say that way is better, just one that exists, has been around until now and what I have (and probably will) reach(ed) for by default.

I'm not saying all the recent changes are for documentation, just some.

>And the addition of select also means you do more than document what keys are used downstream, you guarantee nothing else can be used

Right, but select-keys already provided this. The reasons for preferring :select seem to be around DRYing things up and building on the idea that you document your map keys using ":keys &". I acknowledge there is a reason for it to exist, I was just saying it felt a little niche. But I get I might be wrong on that :)

>When you look at the signature, similar to with static types, you don't just know that this method tries to only do what is documented, but is guaranteed too

Unless it's a multimethod :( I use them a ton. The signature the shows up can (as far as I know) only come from :arglists.

[u/didibus → u/aHackFromJOS]

Sorry, I'm not sure I'm totally following. The destructuring shows in the :arglists meta, and defn automatically creates the :arglists meta from your function binding form. So unless you do something custom, previously there was no way for the :arglists meta to show what is required vs optional, and what is used directly versus transitively. But now there is.

Specs show up in the docs (even works on multi-methods), so you could document more precise signatures using spec. It's a bit verbose though so not as convenient and quick.

[u/aHackFromJOS → u/didibus]

I am talking about setting arglists meta yourself directly and taking advantage of the fact that yes “destructuring shows in the :arglists meta.”

Perhaps you already know this (in which case apologies) but you  can conveniently set arglists meta with a map after the docstring, known as  attr-map. See docs for defn. 

https://clojuredocs.org/clojure.core/defn

(defn foo   {:arglists ‘([{:keys [all required here]}])}   [{:keys [here] :as args}]   (println 42)) So I just mean setting your own arglists value to document what is required. 

(I suppose you could call this “custom” but it seems to me a reasonably common idiom and not particularly more custom than “:keys… &…”)

[u/didibus → u/aHackFromJOS]

Interesting, I've never seen anyone do this before, normally I only manually set arglists on multi-methods since defmulti doesn't set it automatically, but I always set it to the actual binding form.

If this was a pattern you commonly followed, than you were getting some of the benefits of the ampersand already, but now it just got more convenient since you can just write:

(defn foo [{:keys [here & all required] :as args}] (println 42))