Clojure Q&A - Recent questions in Clojure

Add assoc-some for constructing maps while skipping nil values

Fri, 17 Jul 2026 18:23:06 +0000

On latest Clojure alpha, we added :keys! (and :syms!/:strs!) check for key presence. They do not check the value (by design). So a map can have the key, with a nil value, and still pass the check:

(let [{:keys! [a]} {:a nil}]
  a)
;; => nil

Sometimes nil is not a valid value for a given key. In those cases, a programmer may want to avoid adding the key at all, rather than adding it with nil. This is the most common idiom today:

(cond-> m
  (some? v) (assoc k v))

A dedicated assoc-some function would help. It skips the key when the value is nil:

(assoc-some {:a 1} :b 2)
;; => {:a 1 :b 2}

(assoc-some {:a 1} :b false)
;; => {:a 1 :b false}

(assoc-some {:a 1} :b nil :c nil)
;; => {:a 1}

destructuring with :keys! and :or

Tue, 14 Jul 2026 19:52:33 +0000

I'm trying Clojure 1.13.0-alpha4. I have a problem with :keys! and :or. The first example works as expected with the old :keys. The second example gives me a syntax error when I switch to the new :keys!. The thirds example works when I avoid the required key in the defaults.

 (let [{:keys [a] :or {:a 1}} {:a 2}] a)
 ;=> 2
    
(let [{:keys! [a] :or {:a 1}} {:a 2}] a)
Syntax error macroexpanding let at (REPL:1:1).
Can't supply default value for required key: :a

(let [{:keys! [a] :or {:b 1}} {:a 2}] a)
;=> 2

require yields confusing "namespace ... not found after loading ..." error if masked by empty test file

Sat, 11 Jul 2026 02:54:34 +0000

My home.clj was requring chess.llm, neither file had compilation issues, so I found this error below very strange and I couldn't figure it out.

user=> (require 'chess.routes.home :reload)                                                                    
2026-07-10 22:09:37,296 [nREPL-session-cedf8a12-a034-475d-a72c-7683c52bca15]
Syntax error compiling at (chess/routes/home.clj:1:1).
namespace 'chess.llm' not found after loading '/chess/llm'

I even tried asking AI for help with troubleshooting but it went down the wrong paths looking for circular dependencies. It wasn't until I copied llm.clj to a different file named caca.clj while only updating the ns declaration "chess.llm => chess.caca" and corresponding requires in my home.clj, that everything loaded correctly.

It turns out that I had an empty test file test/chess/llm.clj that was somehow messing up the compilation, and removing this empty test file file, or adding a proper ns declaration, solved the issue.

I'm reporting this because it would help the next Clojure developer if the error message were more indicative of the bad test file, perhaps by including the full file path.

Here's the AI-generated explanation of this report:

Title

require yields confusing "namespace not found after loading" error if masked by empty file earlier in classpath

Environment

Clojure Version: 1.11+ / 1.12
Build Tool: Leiningen / Clojure CLI

Description

When attempting to require a valid Clojure namespace, if a completely empty .clj file with the exact same relative file path exists earlier in the classpath sequence (for example, in test/ when test/ precedes src/ in the active profile), Clojure throws a misleading error.

The compiler successfully locates and loads the empty file, but because the file lacks an (ns ...) declaration, it fails to find the registered namespace in memory. This effectively masks the actual, working source file further down the classpath, resulting in an error message that mistakenly implies the namespace naming is incorrect, rather than indicating a classpath prioritization issue.

Steps to Reproduce

Create a project layout where test/ takes priority over src/ on the classpath.
Create a valid file at src/chess/llm.clj containing:
`clojure
(ns chess.llm)
(defn call-llm [] :ok)
`
Create an empty file at test/chess/llm.clj (size 0 bytes, absolutely no content).
Launch a REPL and evaluate: (require 'chess.llm)

Expected Behavior

The compiler should either:
1. Skip empty files on the classpath and continue searching subsequent paths for a matching file containing a valid ns form.
2. Throw a more descriptive lifecycle error indicating which exact file path was targeted (e.g., namespace 'chess.llm' not found after loading empty file: test/chess/llm.clj).

Actual Behavior

The execution fails completely with a vague stack trace:
`clojure
Caused by: java.lang.Exception: namespace 'chess.llm' not found after loading '/chess/llm'
`

Additional handling for `&` symbol in map destructuring for :keys/:syms/:strs could be a breaking change.

Thu, 09 Jul 2026 10:01:25 +0000

Before 1.13.0-alpha1:

(let [{:keys [&]} {:& 1}] &)
;; => 1

After:

(let [{:keys [&]} {:& 1}] &)
Syntax error compiling at (REPL:1:1).
Unable to resolve symbol: & in this context

Will :keys! work with nested maps?

Mon, 06 Jul 2026 15:20:35 +0000

While learning about the new support for checked :keys!, I came across this test case for nested maps: https://github.com/clojure/clojure/blob/master/test/clojure/test_clojure/data_structures.clj#L1382-L1390.

I have two questions.

First, does this test imply that :keys! will also be supported in nested destructuring?

Second, I think there may be a small issue with one of the test cases. It checks that the following destructuring throws an exception:

{a :a {aa :a :as m :keys! [b c & d e]} :b} (dissoc sample-map :c)

The test passes, but it's not obvious whether that's because :c has been removed from the map or because :e is listed in :keys! without being present. Since the previous test doesn't include :e, it's a bit ambiguous which condition is actually being exercised.

To make the intent clearer, would it make sense to split this into two separate test cases?

One that removes :c and uses :keys! [b c & d], verifying that the missing required key causes the exception.
Another that keeps :c but uses :keys! [b c & d e], verifying that the non-bound but missing :e is what triggers the exception.

Namespaced map conversion fails when namespace keyword starts with a number

Mon, 06 Jul 2026 15:16:32 +0000

It looks like Clojure has no problem with either :0 or :0/a, but when used together in a namesapced map it fails during some internal conversion.

Worst part: it prints back an unreadable form when if I feed it {:0/a :val}

user=> :0
:0
user=> :0/a
:0/a
user=> {:0/a :val}
#:0{:a :val}
user=> #:0{:a :val}
Syntax error reading source at (REPL:45:5).
Namespaced map must specify a valid namespace: 0
:a
:val
Syntax error reading source at (REPL:45:13).
Unmatched delimiter: }

Possibly avoidable identity call to force instance method on Class literals

Thu, 02 Jul 2026 23:47:10 +0000

As of Clojure 1.13.0-alpha2, (.method ClassName) expands to (.method ^Class (identity ClassName)).

This is to force (.method ClassName) to always be an instance method. Without this, it would expand to (. ClassName method), which may instead be interpreted as a static method.

For example, (.getMethods String) expands to (.getMethods ^Class (identity String)).

This was introduced in these two commits:
- force instance member interpretation of (.method ClassName), e.g. (.getMethods String) works
- added autohinting to Class in macroexpansion of (.instanceMethodOfClass Classname) calls

Since then, Clojure has added support for qualified methods which we can use to reliably propagate the tag without any runtime changes. For example, expanding to (Class/.getMethods String) is now equivalent to (.getMethods ^Class (identity String)) in terms of tag propagation.

I have a proof-of-concept here that includes disassembled and decompiled output before and after the change. The net effect of using qualified methods in this case under direct linking is a removal of a single method call to identity:

   3: invokestatic  #20                 // Method clojure/core$identity.invokeStatic:(Ljava/lang/Object;)Ljava/lang/Object;

The effect is more substantial without direct linking (not included in the PR), with clojure.core/identity also being added to the static initializer.

I've also experimented with expanding to (. (do String) getMethods) (see earlier commits in that PR), which seems to also work and might be another approach.

error printed using pprint in clojure 1.13.0-alpha1

Thu, 02 Jul 2026 20:22:36 +0000

❯ clj -Sdeps '{:deps {org.clojure/clojure {:mvn/version "1.13.0-alpha1"}}}'
Clojure 1.13.0-alpha1
user=> (clojure.pprint/pprint :foo)
Execution error (ClassCastException) at clojure.pprint.proxy$java.io.Writer$IDeref$PrettyFlush$4923d848/flush (REPL:-1).
class clojure.pprint.proxy$java.io.Writer$IDeref$PrettyFlush$4923d848 cannot be cast to class clojure.pprint.PrettyFlush (clojure.pprint.proxy$java.io.Writer$IDeref$PrettyFlush$4923d848 is in unnamed module of loader 'app'; clojure.pprint.PrettyFlush is in unnamed module of loader clojure.lang.DynamicClassLoader @36a58466)
:foo

reported by djblue in #clojure-dev

Syntax-quoted lists can return nil, differs from ClojureScript

Sun, 28 Jun 2026 20:43:55 +0000

Syntax quoted lists can return nil if only empty seqables are spliced into it:

Clojure 1.12.5
user=> `(~@[])
nil
user=> `(~@[] ~@[])
nil

However, the implementation then ensures syntax-quoted empty lists are not nil:

Clojure 1.12.5
user=> `()
()

ClojureScript returns an empty list in these cases:

`(~@[])
=> ()
`(~@[] ~@[])
=> ()

The expansion of syntax quote itself is not necessarily a problem if it differs between platforms, but here the evaluation of the expansion differs. This can cause macros to behave differently between platforms (e.g., JVM Clojure vs bootstrapped cljs).

This behavior seems to be present with all versions of Clojure including 1.0.0, so perhaps the ship has sailed here. I went searching for an existing issue or documentation and AFAICT only CLJ-1425 mentions this oddity.

The reference docs for Syntax Quote also seem to contradict this behavior:

For Lists/Vectors/Sets/Maps, syntax-quote establishes a template of the corresponding data structure.

Why is aset at least 25 times faster than aset-long?

Mon, 15 Jun 2026 13:19:24 +0000

Working with primitive long arrays, we discovered that aset-long is around 25 times slower than aset, when called statically. Presumably this is because of the inline path for aset. Having a specialised aset-longimplies, to me at least, that the specialised version is going to be faster. I'm inferring that aset-lobg was added for improved performance when invoked through a higher order funciton. Would adding an :inline to aset-long et al be considered? or at least a doc string update to warn about the lower performance?

There is an existing issue for this https://clojure.atlassian.net/browse/CLJ-2840

Why do literal vectors ignore type hinting?

Fri, 12 Jun 2026 21:57:51 +0000

When calling a method on an instance of a Java class that takes a Collection<? extends Something> as the argument, I've tried the following:

(.theMethod ^SomeClass inst ^Collection [thing1 thing2])

Unfortunately, when I'm using lein check this gives me a reflection warning of:

call to method theMethod on example.SomeClass can't be resolved (argument types: clojure.lang.IPersistentVector).

I can fix this by binding it to a symbol with a type hint:

(let [^Collection things [thing1 thing2]]
  (.theMethod ^SomeClass inst things))

What is going on that the literal vector can't be type-hinted in place?

Consider including a built-in wrapper around `java.net.http.HttpClient` in future versions of Clojure

Mon, 08 Jun 2026 01:37:14 +0000

Java 9 introduced java.net.http.HttpClient[1] with support for HTTP/1.1, HTTP/2 as well as WebSocket along with other features. It was later standardized in Java 11[2] and has become one of the top picks for Java programs. The latest version of the HTTP client shipped with Java 26 also added support for HTTP/3.[3]

It would be nice for future versions of Clojure that are based on Java 11+ to include a new namespace with wrapper functions around java.net.http.HttpClient to make it easier (without all the OOP ceremonies) to work with HTTP in Clojure programs out of the box without relying on any 3rd-party libraries.

Examples of prior art:

[1] https://openjdk.org/jeps/110
[2] https://openjdk.org/jeps/321
[3] https://openjdk.org/jeps/517

Object.clone() confusion

Fri, 05 Jun 2026 21:58:46 +0000

Consider the following function:

(defn clone [x] 
  (try (.clone x) 
  (catch CloneNotSupportedException _ ...)))

If the arg implements Cloneable, it works, but the call is reflective. If it doesn't, then it fails with java.lang.IllegalArgumentException: No matching field clone for class ....

I can get it to work by catching Exception instead, but it feels wrong :(

Any suggestions?

Changing type tags can lead to cryptic errors

Fri, 05 Jun 2026 08:03:00 +0000

Reporting this as an example of a particularly cryptic error message. Admittedly not the most common thing, but when doing REPL-driven dev with code that uses primitive type tags it can happen.

The issue here as I understand it is that IFn contains a few hundred interfaces with some permutation of primitive input and output types, with names like LLO and ODOL. Functions that call this are compiled to call the primitive interface to avoid boxing,rather than the generic IFn. If the function is then redefined without or with different primitive tags, then the compiled calling code is no longer calling the right interface.

(defn foo ^long [^long x]
  x)

(defn bar []
  (+ (foo 3) (foo 4)))

(bar)

(defn foo [x] x)

(bar) ;;=> throws: class my.ns$foo cannot be cast to class  clojure.lang.IFn$LL

Request: allow a user function to be specified as the target of clojure.main/report-error

Tue, 02 Jun 2026 23:53:32 +0000

The three current targets (file, none, stderr) all serialize all of the error data to a string. During development, it would be convenient to be able to define a function that is called with the exception instance. This function might capture additional application state, or open a window in the user's editor, etc.

Note that it is not possible to work around this by replacing report-error itself because the entire clojure.main namespace is AOT-compiled, so alter-var-root has no effect.

See https://github.com/clojure-emacs/cider/issues/3850 for an example where this feature would be helpful.

`eval` using functions with metadata

Mon, 01 Jun 2026 14:33:00 +0000

TIL:

(eval (list + 1 2)) ; works
(eval (list (var-get #'+) 1 2)) ; works
(eval (list (fn [a b] (+ a b)) 1 2)) ; works

(defmacro m [] `(~(fn [a b] (+ a b)) 1 2))
(m) ; also works

;; however, if the function has any metadata:
(eval (list (with-meta + {}) 1 2))
;; ^ fails, No matching ctor found for class clojure.lang.AFunction$1

This was unintuitive to discover.

I solved it locally with a little helper:

(defn val->expr [v]
  (if (symbol? v)
    `'~v
    (cond-> v
      (and (fn? v) (not (nil? (meta v))))
      (-> (with-meta nil)
          (list (-> v meta (update-vals val->expr)))
          (conj `with-meta)))))

But this takes special handling. I wonder if something similar would not be possible on a "matching ctor"-level, possibly also for comp, every-pred?, etc. It would be fairly trivial even in userland to have versions of these functions which carry metadata sufficient to recreate expressions, e.g. comp storing the list of functions, and then eval, on encountering No matching ctor found for class clojure.core$comp$fn__5921, can instead pull out the list of functions from that value and evaluate (list* comp (:composed-fns (meta v))) (or some such) instead.

I think this would be great to have in the core lib, at least for metadata and core libs functions like comp, some-fn, every-pred?, and complement.

Note, I'm not talking about adding or changing ctors for these necessarily. A hook for taking unconstructable values and making a constructable value out of them would serve just as well, maybe even a multifn.

Strictly in userland and without core lib support, I suppose the cleanest way to do something like this is a custom protocol and probably monkeypatch some core libs functions (maybe eval?)

So I suppose my questions are:

Is this something you agree would be good to have in general? Or is this by design for some reason I can't see?
Would this be good and practical to have in the corelib? Oughtn't be a breaking change at least
If no, is there currently any sane way to apply my solution in a more systemic way than wrapping every relevant value with a val->expr call?

Should reduce-kv support String?

Fri, 29 May 2026 20:42:43 +0000

I like to use reduce-kv on vectors, where the k is the index and the v is the k-th element of the vector. IMHO, it would be convenient if reduce-kv could also work directly on a String. However, IKVReduce isn't implemented for String so that fails. You can use (vec "my-string") as a work-around, but maybe suffer a bit on performance.

I think something like this would work:

(extend-protocol clojure.core.protocols/IKVReduce
java.lang.String
(kv-reduce [^String s f init]
  (let [cnt (.length s)]
    (loop [i 0 res init]
      (if (< i cnt)
        (let [ret (f res i (.charAt s i))]
          (if (reduced? ret)
            @ret
            (recur (unchecked-inc i) ret)))
        res)))))

However, the guidelines say I shouldn't extend a protocol that I don't own to a type that I don't own.

By the way, (reduce conj [] "Foobar") works as you would expect because String implements clojure.core.protocols/InternalReduce so maybe that's a good precedent.

Consider allowing passing two arguments to sets used as functions

Tue, 26 May 2026 13:44:16 +0000

Similar to how get works with the 3rd not-found argument.

It already works in CLJS:

ClojureScript 1.12.116
cljs.user=> (#{:a} :b :c)
:c

In Clojure, it errors out:

Clojure 1.12.0
user=> (#{:a} :b :c)
Execution error (ArityException) at user/eval1 (REPL:1).
Wrong number of args (2) passed to: clojure.lang.PersistentHashSet

The behavior of `filter` on infinite sequences in Transducers

Sun, 24 May 2026 05:38:39 +0000

Could you tell me where I can find information understanding the difference in behavior below?

user=> (clojure-version)
"1.12.5"
user=> (def iter1 (eduction (filter even?) (range)))
#'user/iter1
user=> (def iter2 (eduction (filter zero?) (range)))
#'user/iter2
user=> (take 1 iter1)
(0)
user=> (take 1 iter2)
;;; Pressed Ctrl-C due to no response

This behavior occurs when the input source is infinite, but I'm confused because I think filter is stateless. Of course, it works fine when Transducers aren't used.

user=> (take 1 (filter even? (range)))
(0)
user=> (take 1 (filter zero? (range)))
(0)

Can clojure builds be reproducible? (new Debian forky requirement)

Tue, 19 May 2026 18:04:14 +0000

Debian now requires packages to be reproducible: https://lists.debian.org/debian-devel-announce/2026/05/msg00001.html and I thought I recalled that compilation, at least, couldn't produce reproducible output (e.g. with respect to variable naming in the class files), and some testing suggests that might still be the case (tested with 1.12.0 via https://diffoscope.org/).

I assume that for Clojure related packages to remain in the next Debian release, we'll need to address the requirement one way or another, if we can, so I wanted to ask about the situation upstream first.

Offhand, I think the main concern is with AOT compilation, which Debian only uses for "leaf" applications, packaged as an uberjar (e.g. leiningen, puppetserver, puppetdb, etc.), and Debian already has infrastructure to make sure that jars are otherwise reproducible (with respect to timestamps, etc.), so the issue there is mostly "just" regarding the file content.

Thanks

`(:k m)` returns `nil` while `(identical? (first (keys m)) :k)` is `true` — two coexisting `Keyword` instances?

Mon, 11 May 2026 12:59:06 +0000

We're seeing what looks like a violation of the keyword-interning invariant in production. The bug is deterministic (repeats thousands of times in the same order on the same Aleph/Netty thread) and is cleared by recompiling the affected namespaces via nREPL.

(when (and (map? result) (nil? (:payload result)))   ; this WHEN fires
  (let [payload-key (->> (keys result)
                         (filter #(.contains (pr-str %) "payload"))
                         first)
        payload-via-key (when payload-key (get result payload-key))]
    (log/warn {:result-type                   (str (type result))
               :result-keys                   (pr-str (keys result))
               :payload-key-equals-literal?   (= payload-key :payload)
               :payload-key-identical?        (identical? payload-key :payload)
               :payload-via-found-key-nil?    (nil? payload-via-key)}
              "diagnostic")))

Logged values when the bug fires:

{:result-type                   clojure.lang.PersistentArrayMap
 :result-keys                   (:payload :aws-xray)
 :payload-key-equals-literal?   true
 :payload-key-identical?        true
 :payload-via-found-key-nil?    false}

So:

The (:payload result) in the when returned nil.
A few lines later, the diagnostic body proves that the first key in (keys result) IS the body-site :payload literal by identity (and therefore by =, since Keyword inherits Object.equals).
(get result that-key) returns the actual non-nil payload value.

PersistentArrayMap.indexOf uses == for Keyword keys, so the only way (:payload result) returns nil while (keys result) yields a key that is identical? to :payload at a nearby site is if the :payload literal at the WHEN site and the :payload literal at the body site are two different Keyword instances, even though they're written identically in one source-level function.

We compareed the :payload literal with the payload-key and found that both have -

identical content hashcode (-383036092)
identical name bytes [0x70 0x61 0x79 0x6C 0x6F 0x61 0x64]
identical codepoints
same classloader

so it really looks like two distinct interned Keyword instances with the same name.

Environment

Clojure 1.12.4
Eclipse Temurin JDK 25, Shenandoah GC, virtual threads enabled
ARM64 (AWS Graviton, ECS Fargate)
Aleph + Netty, transit-clj/transit-java for decoding

Questions

Could this be a bug in JVM / Clojure runtime?
Has similar behavior been seen in other cases?
What more evidence could we capture?

Reflection warning when long hint on an argument

Fri, 01 May 2026 19:49:31 +0000

Hi,

I noticed some reflection warning that goes away when removing a hint from fn arguments. I would like to understand the reason for this.

Example, loading this code

(set! *warn-on-reflection* true)

(defn duration-of-seconds
  (^java.time.Duration [^long seconds]
   (java.time.Duration/ofSeconds seconds)))

(defn sleep
  [seconds]
  (Thread/sleep (duration-of-seconds seconds)))

Raises a reflection warning:

call to static method sleep on java.lang.Thread can't be resolved (argument types: java.lang.Object).

However, just removing the ^long hint from the duration-of-seconds fn argument, makes the reflection warning go away.

Thanks!

"Nested" vs "lateral" exception causes

Sun, 05 Apr 2026 14:18:26 +0000

Currently, clojure.core/ex-info must take a msg and data map, and may take a cause, which must be another Throwable, which may have its own cause, etc. etc..

This supports the case of "nested" exceptions quite well, e.g. in the case of compilation exceptions being caused by macroexpansion exceptions, potentially with their own cause, and works well for fail-on-first-problem situations.

There's also the situation of "lateral" exceptions, e.g. in the case of test runners or static analysers, which is not supported. In this case, if we take lazytest as a concrete example, the test runner throws an exception if any of the test cases it runs throws an exception, but the overall cause of the overall exception, conceptually, is all the individual exceptions.

Currently, the only to do this is to make some bespoke thing in the data map.

I propose changing clojure.core/ex-info to take [msg map & causes], which would be a non-breaking change (or, while we're at it, make the map arg optional as well and default it to {}, but that's a separate topic).

That leaves the question of how to handle ex-cause. To my understanding, to change it to return the cause or the list of causes, would maybe be a breaking change for general exception handling libraries or something, but would not imo pose any significant problem. Alternatively, we might have ex-causes to always return a list, and change ex-cause to (comp first ex-causes).

Any thoughts? I don't trust myself to spearhead a PR alone on this but I'd love to contribute, certainly the pure-clojure side of things seems straightforward enough (and I'd love to patch this into lazytest, but that's again a different topic).

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)

Optimize `eduction`

Fri, 03 Apr 2026 14:25:17 +0000

Problem statement

Eduction is useful part of the transducer ecosystem, which has a benefit/aim of improved performance. However, the function eduction only has a single varargs arity, which adds multiple function calls and and seq traversal allocations.

As seen in this PR to clj-kondo, manually passing in an xform directly can improve both overall performance and lower allocations.

Proposal

Adding arities to eduction can sidestep those allocations and seq traversals, improving baseline performance of all eduction invocations.

(defn eduction2
  {:arglists '([xform* coll])
   :added "1.7"}
  ([coll] (->Eduction identity coll))
  ([f1 coll] (->Eduction f1 coll))
  ([f1 f2 coll] (->Eduction (comp f1 f2) coll))
  ([f1 f2 f3 coll] (->Eduction (comp f1 f2 f3) coll))
  ([f1 f2 f3 f4 & args]
   (->Eduction (apply comp f1 f2 f3 f4 (butlast args)) (last args))))

requiring an empty .clj without an alias should fail as with an alias

Thu, 02 Apr 2026 18:48:37 +0000

if file a/b/c.clj is "empty"

it creates an empty ns: (and does not fail) when doing

(require '[a.b.c])

while when using ":as" it fails correctly with error:

(require '[a.b.c] :as c)

Syntax error compiling at ... ; namespace 'a.b.c' not
found after loading '/a/b/c'

see here for initial discussion:
https://clojurians.slack.com/archives/C03S1KBA2/p1775155101843229?thread_ts=1775153939.803389&cid=C03S1KBA2

Is taggedliteral's equality check inefficient?

Fri, 27 Mar 2026 13:43:44 +0000

Following on from a very interesting article about tagged literals: https://buttondown.com/tensegritics-curiosities/archive/when-you-run-out-of-types/ I noticed that the implementing class checks for value equality before checking for tag equality.

if (form != null ? !form.equals(that.form) : that.form != null) return false;
if (tag != null ? !tag.equals(that.tag) : that.tag != null) return false;

This leads to the following type of comparison that could be answered immediately but instead takes over a second:

impl=> (time (= (tagged-literal 'foo (seq (range 1e7))) (tagged-literal 'bar (butlast (seq (range 1e7))))))
"Elapsed time: 1911.677375 msecs"
false

it checks if these huge seqs are equal and then compares the associated symbols. Swapping this seems identical semantically but with less computation.

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.

Controlled Bailout, Jira issue 2213

Sat, 21 Mar 2026 10:14:48 +0000

I would like to improve Issue 2213 as follows. Do you think, this makes sense? Shall I become contributor for this?

The new description would be:

When developing Input-Process-Output tools I am often in the situation, that I have a sequence of activities (e.g. opening a file, spec checking a file, calling external tools, creating files), which each could fail in certain ways. Clojure does not have a good way to control such a sequence of activities in a way that all sorts of things, which could go wrong, can be handled comfortably. In imperative programming languages concepts like early exit or bailout are used. These are not not very functional. Unfortunately practical problems are often like this.

The issue is a bit more general and a solution would be nice not only for those who develop such sort of tools. So I can give a simple example.

(let [config-file (get-file-from-network xy)
      config-file (parse-edn config-file)
      syntax-ok?   (spec-check config-file)]
  (do-something-with config-file))

As all these steps can fail, we could instead implement it like this.

(if-let [config-file (get-file-from-network xy)]
  (if-let [config-file (parse-edn config-file)]
    (if (spec-check config-file)
      (do-something-with config-file))))

Now the code has suffered already a lot. The sequential nature of the problem is lost. And it is not even doing what we need. We have to report to the user what went wrong.

(if-let [config-file (get-file-from-network xy)]
  (if-let [config-file (parse-edn config-file)]
    (if (spec-check config-file)
      (do-something-with config-file)
      :file-has-syntax-errors)
    :file-not-valid-edn)
  :file-cannot be openned)

But this is still not doing what we need. We have to provide more information about each failure. If a file cannot be openned, is it because the file does not exist or we do not have read permissions? And what did the spec check tell us? So we cannot just use nil as a universal failure. We must deliver more information when failing. And we cannot use if-let, either. So we are not even done.

This problem report asks for a better solution for this conceptual challenge.

This example depicts a conflict that should not happen when using an appropriate programming language: First we are able to quickly make a prototype. But in the end the final code has not much in common with the first code any more. The final design is not driven by the problem domain, but by the technical need for an error handling. The need for a bailout mechanism in this example imposes too many huge code changes.

The principal problem with all these solutions is that they coerce a sequence of actions into something which is not a sequence. If your problem is a sequence, then the implementation should also be a sequence.

Idea: Exceptions

As an alternative implementation I went with Exceptions. But it feels wrong, because I am talking about things, that are expected to fail. I cannot just use the Exceptions that are comming out of Java for example when opening a file for read. I need detailed information, what went wrong. If you are a command line tool, it is expected from you, that you provide good error messages. I ended up catching and rethrowing exceptions everywhere in the program.

Idea: Like for/doseq

For me I created a small macro, that extends let. Then I use this syntax:

(let [[config-file error] (get-file-from-network xy)
      :escape     error
      config-file (parse-edn config-file)
      syntax-ok?   (spec-check config-file)]
  (do-something-with config-file))

This often allows a surprisingly intuitive code. For example here:

(let [[config-file error-code] (get-file-from-network xy)
      :escape     (if (= error-code :does-not-exist) 
                    :file-xy-does-not-exist)
      :escape     (if (= error-code :io-error)
                    :file-xy-cannot-be-read)
      [config-file error-code] (parse-edn config-file)
      :escape     (if error-code :file-xy-not-legal-edn)
      syntax-ok?   (spec-check config-file)]
  (do-something-with config-file))

This is inspired by the for/doseq. But I don't claim that this is a good solution for Clojure (although I think so). But I think, the let macro is a good candidate when improving how Clojure can be used for such imperative things.

Idea: Using `if-let`

I also investigated the solution, that was originally proposed by this issue.

(if-let [config-file (get-file-from-network xy)
         config-file (parse-edn config-file)
         config-file-ok? (spec-check config-file)]
  (do-something-with config-file)
  :error)

This problem with this solution is that none of the bindings are available in the else part. That makes it very hard to react accordingly. This is a nice and small new language feature. But I don't think, that in practice it would be of help so often. The example from the original issue was very artificial with mathematical operations that cannot fail. The first draft of this issue with that artificial example does not actally describe a real problem. That is why this issue has completelly been rewritten.

Or course we could still bind everything, which was not failed. But I don't think, we would want that. It would have very interesting consequences to the compiling model.

Idea: Threading macros

As this issue is a about a sequence of activities, a new type of threading macro (e.g. let->) could also be an intuitive solution. But I have not tried anything like this.

Final Words

The principle challenge is, that all these solutions establish a sort of alternative control flow. It is a hard challenge to do this right, especially in a functional language. Like exceptions, that immediatelly exit and magically jump somewhere else. Clojure as a practically language could address this challenge.

Evaluating forms using eval can create a valid undesirable recursion point

Mon, 16 Mar 2026 23:17:54 +0000

When the eval function in Clojure is called with an argument that is an instance of IPersistentCollection which likely isn't a special def-like form (the first element isn't a symbol at all or it does not start with "def"), the form is first wrapped in an anonymous function which then gets compiled and invoked, which indirectly evaluates the original form.

There aren't any extra checks performed and it makes forms like these 2 valid, which should normally be rejected and a compiler exception should be thrown:

(recur)

(let []
  (print "Hello")
  (Thread/sleep 1000)
  (recur))

where the 2nd form keeps printing "Hello" and loops infinitely over the outer wrapper function.

Optimized str function

Mon, 16 Mar 2026 11:12:53 +0000

Opimized version of str function:

(defn my-str
  (^String [] "")
  (^String [^Object x]
   (if (nil? x) "" (. x (toString))))
  (^String [^Object x & ys]
   (let [sb (StringBuilder. (if (nil? x) "" (. x (toString))))]
     (loop [ys (seq ys)]
       (if-not (nil? ys)
         (let [x (.first ys)]
           (if-not (nil? x)
             (.append sb (.toString ^Object x)))
           (recur (.next ys)))))
     (.toString sb))))

Benchmarks:

(let [xs (vec (range 1000))]
    (criterium/bench
      (apply my-str xs)))

Evaluation count : 2577840 in 60 samples of 42964 calls.

         Execution time mean : 23.611394 µs

(let [xs (vec (range 1000))]
    (criterium/bench
      (apply str xs)))

Evaluation count : 1375200 in 60 samples of 22920 calls.

         Execution time mean : 42.015320 µs

It's difficult to figure out options I can pass to slurp function.

Fri, 27 Feb 2026 06:41:39 +0000

(doc slurp) says

clojure.core/slurp
([f & opts])
Opens a reader on f and reads all its contents, returning a string.
See clojure.java.io/reader for a complete list of supported arguments.

(doc clojure.java.io/reader) says

clojure.java.io/reader
([x & opts])
Attempts to coerce its argument into an open java.io.Reader.
Default implementations always return a java.io.BufferedReader.

Default implementations are provided for Reader, BufferedReader,
InputStream, File, URI, URL, Socket, byte arrays, character arrays,
and String.

If argument is a String, it tries to resolve it first as a URI, then
as a local file name. URIs with a 'file' protocol are converted to
local file names.

Should be used inside with-open to ensure the Reader is properly
closed.

I read the source code, and I was confused even more.

Is it legal for a namespace to start with a number?

Mon, 23 Feb 2026 18:53:53 +0000

There are rules (informally in the spec, formally in the reader) about disallowing symbols to start with numbers: (def 1asdf 5) However, there aren't rules about namespaces (either middle segments or as the final segment) starting with numbers, leading to their usage in the wild. (For example: https://github.com/marick/Midje/tree/bee206983db22c6dc92044fd7b5b0365bbd44fc6/test/implementation/parsing/0_to_fact_form)

Is this intentional? Should such namespaces be considered legal or not?

Feature Request:Make anonymous fn/reify class name IDs per namespace instead of one global counter

Wed, 18 Feb 2026 15:34:38 +0000

Compiled anonymous functions and reify classes get names like ns$fn__4532, where the numeric suffix comes from a global AtomicInteger counter
(RT.nextID()).

This counter is shared across the entire runtime and is consumed by fn classes, reify classes, constants tables, gensyms, etc.

The problem is that because the counter is global, any code change shifts the IDs for everything compiled after it. This makes profiling across builds
really painful, you can't meaningfully compare flame graphs because all the class names change even in code you didn't touch.

I'd like to propose scoping the ID counter per-namespace instead. Since the namespace is already part of the class name prefix, uniqueness is still
guaranteed. This would eliminate the cascading effect across unchanged namespaces and make profiling diffs actually useful.

I'm not sure what's the downsides of this, but from what I saw of AtomicInteger, it isn't used a lot to break things.

Thank you!

Is it valid for metadata to have metadata?

Thu, 12 Feb 2026 15:45:20 +0000

Hello,

I am implementing a pretty printer and while adding/testing support for *print-meta* I noticed that pr prints an object whose metadata has metadata in the following way:

user> (binding [*print-meta* true]
        (pr-str (with-meta 'foo (with-meta {:bar :baz} {:frob :zork}))))
"^^{:frob :zork} {:bar :baz} foo"

When reading such a form, only the "outermost" metadata is preserved:

user> (binding [*print-meta* true]
        (let [s (pr-str (with-meta 'foo (with-meta {:bar :baz} {:frob :zork})))
              o (clojure.edn/read-string s)]
          {:o o
           :meta (meta o)
           :metameta (meta (meta o))}))
{:o foo, :meta {:bar :baz}, :metameta nil}

The behaviour is the same for clojure.core/read-string and also the tools.reader readers.

Can anyone clarify for me if this is either:

simply GIGO
a bug in the printer
a bug in the readers
a state that should be somehow disallowed
something else?

Neither the metadata reference nor the reader reference explicitly allow or disallow such a thing, as far as I can tell. Should they?

N.B. this is not an issue in any kind of production context and I'm not aware of any library or program that constructs such a thing. It's simply something I tested to see if/how it would break the pretty printer I'm building.

EDIT:

I dug into this some more with Nicola. Here's a perhaps much clearer case that demonstrates the reader isn't propagating nested metadata:

user> (let [o ^^:foo {1 2} {3 4}]
        {:o o :meta (meta o) :metameta (meta (meta o))})
{:o {3 4}, :meta {1 2}, :metameta nil}

:metameta should be {:foo true}.

In this section of MetaReader.invoke we are iterating over the entries of the meta map and manually associng them into the existing meta of the object; any metadata on the meta map itself is not preserved. I have a patch that adds a failing test case and correctly propagates the the meta map's metadata. If this is worth a ticket then I'm more than happy to attach it to that or send it to you directly.

bit-count in cljs but not clj

Fri, 30 Jan 2026 09:21:40 +0000

The bit-count function ships as part of CLJS but not CLJ, which means I end up using a reader conditional to use Long/bitCount on the JVM side when I write cljc files. It would be nice if I could just use bit-count.

(I chose "compiler" for category because there's no option for "standard library")

definterface doesn't expose gen-interface's :extends for interface extension

Mon, 26 Jan 2026 19:49:08 +0000

gen-interface allow :extends to specify one or more interfaces, which will be extended by this interface.

definterface doesn't expose this.

Use case is working with primitives (where protocols don’t help), to get things to dispatch nicely in a zero boxing primitive transducer implementation.

How to force clojure.spec generator to skip a field

Thu, 15 Jan 2026 07:58:46 +0000

(gen/let [x (s/gen (s/keys :opt [::a]))
          y (s/gen (s/keys :opt [::a]) {::a ???})])

If x generates without ::a, I'd also like to generate y without ::a. I can't presently see a way to express that.

clojure.core/subs should use type hints of ^CharSequence, NOT ^String

Tue, 13 Jan 2026 18:10:48 +0000

This is related to this ancient ask, but it would be ideal if clojure.core/subs was type hinted with ^CharSequence rather than ^String, and used the subSequence() method instead of substring() (since the latter doesn't exist in CharSequence).

The single parameter version of subs would need to call s.length() as the second argument in the call to subSequence() (there is no single-arg version of that method, unlike substring()).

More generally, there are substantial benefits in using CharSequence instead of String throughout Clojure core, not only in the context of Java interop, but also when using custom String-like data structures (e.g. ropes).

[edit] @alexmiller mentioned this in another forum (and I'm capturing it here for posterity), but this might also require that the result be stred, to ensure the return type remains unchanged (subSequence() returns a CharSequence, unlike substring, which might break callers). There may be performance implications of adding that call for types other than String (but existing callers should be unaffected, since String.toString() is identity).

Is invoking an anonymous primitive function expected to use the primitive interface?

Tue, 13 Jan 2026 14:28:41 +0000

Invoking an anonymous primitive function seems to not use the primitive interface.

(set! *unchecked-math* :warn-on-boxed)
(let [f (fn ^double [] 1.0)]
  (+ 1.0 (f)))
;; Boxed math warning

Is this expected behaviour?

Reader docs say foo.bar is a qualified symbol but qualified-symbol? is false

Mon, 12 Jan 2026 21:44:25 +0000

The reader reference on clojure.org says "Symbols containing / or . are said to be 'qualified'." but qualified-symbol? is defined to return true if the argument is a "symbol with a namespace".

Almost every reference to a "qualified symbol" in the docs (on clojure.org) refers to a "namespace-qualified symbol" or a "fully-qualified symbol" (also with a namespace).

The only other type of "qualified symbol" mentioned is on the evaluation page where it refers to a "package-qualified symbol" for a Java class name.

I suggest changing that original sentence to read "Symbols containing / are said to be 'namespace-qualified' or 'fully-qualified'. Symbols containing . are said to be 'package-qualified' if they identify a Java class name." or something similar.

Literals for Unicode code points (and perhaps also sequences thereof)

Mon, 12 Jan 2026 20:02:41 +0000

Context
For historical reasons the JVM type system's support for Unicode code points is poor, and while this is usually invisible to the developer it becomes a hassle when String literals containing non-Latin1 code points are used in code. It also becomes particularly problematic when cross-platform (cljc) code is attempting to do this, since other platforms may not share this historical oddity so solutions that "work" in ClojureJVM may break in other dialects.

For example, the transgender flag emoji (a single grapheme cluster that happens to be defined by 5 Unicode code points) cannot easily be constructed at the REPL or in a source file without detailed knowledge of the JVM's history (and associated knowledge of UTF-16, an increasingly obsolete character encoding).

Using the documented code points for this grapheme cluster with the JVM's Unicode escaping mechanism does not give the expected outcome:

The correct, but unintuitive solution is to remember that the JVM does not directly support Unicode code points in the supplemental planes, and then to translate the supplemental code point U+1F3F3 into its UTF-16 code unit / surrogate pair representation:

Note: I had to use screenshots for this, since ask.clojure doesn't appear to support Unicode supplemental code points properly either...

Question/request/proposal
Clojure can sidestep this issue in a purely accretive manner, providing better consistency across the JVM and other runtimes, by adding direct support for Unicode literals.

This would involve adding a new literal syntax that represents a single Unicode code point, and perhaps also a new literal syntax that represents a sequence of Unicode code points (perhaps supporting not only the novel Unicode code point literal, but also the existing Character and String literals). Both of these new literals would produce a standard JVM (or JavaScript, or ...) String object, in whatever native encoding those objects employ on their respective platforms - after such literals are read, it's all just the extant String data type - there is no runtime impact.

An example literal syntax

While I am not proposing a specific syntax for these new literals here (though such a task is a necessary step), for illustrative purposes here is an example of what these literals might approximately look like:

Single Unicode code point literals:

#U+0061: produces a String containing the Latin letter a: "a"
#U+1F921: produces a String containing the clown emoji (which ask.clojure cannot display)

Sequences of Unicode code point literals:

#U+[U+0061 U+0020 U+1F921]: produces the 3 grapheme cluster String: "a <clown emoji>"
#U+["a " U+1F921]: produces the same String, but demonstrates why it may be useful to support a mix of literals within the sequence (for readability)
#U+[\a \space U+1F921]: ditto
#U+[U+1F3F3 U+FE0F U+200D U+26A7 U+FE0F]: produces a String containing a single grapheme cluster (the transgender flag emoji)

This final example is an ideal test case, since the transgender flag emoji is a single Unicode grapheme cluster, defined by 5 Unicode code points, but on the JVM (for the historical reason listed originally) is made up of 6 Characters.

Note that the sequence literal may not be necessary, since str could be used with the single code point literal syntax; e.g. (str #U+1F3F3 #U+FE0F #U+200D #U+26A7 #U+FE0F). Whether shifting the cost of string concatenation from read-time to runtime matters or not is another topic worthy of deeper consideration.

Other notes
Orthogonal to this proposal (at least from a Clojure core perspective; from a user perspective they're closely related), it would also be useful if Clojure core (perhaps in the clojure.string namespace) had functions to turn Strings into sequences of code points (as integers) and vice versa. Both the JVM and JavaScript provide native APIs for doing this (and presumably other platforms do too), but providing these as standard functions in Clojure core (similar to what was done with parse-long, parse-double, and parse-boolean in Clojure v1.11) has value and is also purely accretive.

CVE-warning in org.fressian/fressian <- org.clojure/data.fressian

Fri, 09 Jan 2026 12:45:21 +0000

Dependency Information
When running clj-watson in a project with

org.clojure/data.fressian {:mvn/version "1.1.1"}

I get the following warning, refering to CVE-2018-10054 (relates to a vulnerability in H2 and its usage in older versions of datomic). I assume this is a false positive.

NAME: org.fressian/fressian
VERSION: 0.6.8

DEPENDENCY FOUND IN:

[org.clojure/data.fressian]

FIX SUGGESTION:

Vulnerabilities

SEVERITY: HIGH
IDENTIFIERS: CVE-2018-10054
CVSS: 8.8 (version 3.1)
PATCHED VERSION: Information not available.

Why does the REPL incorrectly display my command after I press enter?

Mon, 22 Dec 2025 15:01:06 +0000

Hello,

I'm having a small bug with the Clojure REPL - when I enter a command, after pressing the enter key, the command gets displayed incorrectly - basically the beginning of the text of the command that I entered is displayed for the first few characters, and then everything after that is overwritten with the same text of the command displayed with an indentation.

Not sure if that's very clear, so I've added a pair of screenshots, "before and after", to illustrate.

This issue seems similar to this older question, although in that case the issue was with the rlwrap library, which was patched afterwards.

Is there a way to fix this?

Octal escape sequence decoding in strings does not stop at non-octal digit

Thu, 18 Dec 2025 09:35:53 +0000

Strings suppose to support standard Java escape sequences, including octal escape sequence: [0-7]{1,3}

In Java decoding of octal sequences stop at the first non-octal digit or any other character if there are 1 or two octal digits in the escape sequence. For example:

jshell> "\18"
$1 ==> "\0018"

But Clojure reads up to 3 potentially octal digits greedily resulting in wrongly consuming non-octal digits:

Clojure 1.12.4
user=> "\18"
Syntax error reading source at (REPL:1:5).
Invalid digit: 8

non-octal characters:

Clojure 1.12.4
user=> "\1d"
Syntax error reading source at (REPL:1:5).
Invalid digit: d

And succeed only when there is line terminator or exact three octal digits in supported octal range:

Clojure 1.12.4
user=> "\1"
""
user=> "\1"
""
user=> "\12"
"\n"
user=> "\123"
"S"
user=> "\123d"
"Sd"

Aliased namespace in tagged literal

Thu, 11 Dec 2025 20:01:16 +0000

Set up

Tagged literals are defined by setting a namespaced symbol in data_readers.clj (or data_readers.cljc). At load, Clojure merges all of the maps defined in data_readers.clj(c) files found on the classpath into a single map. At read time, the symbol following a # is checked in the merged data readers map, which determines which var to call with the contents of the following form.

For example, #foo/bar [1 2 3] leads to the reader calling the equivalent of (get *data-readers* 'foo/bar).

Problem statement

The tag of a tagged literal must be determined when it is created. The namespace of the chosen tag is set and cannot be changed by a user. Unlike a fully qualified symbol with an aliased namespace, a tagged literal must what was chosen by the author.

As an author of tagged literals, I want to write tags that will not clash with other tags by giving them complex/deep namespaces. For example, {noahtheduke.lazytest/expect noahtheduke.lazytest/expect}.

As a user of tagged literals, I want to alias the namespace of tags and use it in my code. For example:

;; in src/data_readers.clj
{noahtheduke.lazytest/expect noahtheduke.lazytest/expect}

;; in test/noahtheduke/example_project/main-test.clj
(ns noahtheduke.example-project.main-test
  (:require
   [noahtheduke.lazytest :as-alias lt]
   [noahtheduke.lazytest.core :refer [defdescribe it]]))

(defdescribe some-test
  (it "works"
    #lt/expect (= 1 2)))

EDN

This is not related to edn at all and any potential change will be to Clojure itself.

`find` docstring enhancement proposal

Thu, 11 Dec 2025 12:41:48 +0000

The docstring for clojure.core/find states

Returns the map entry for key, or nil if key not present.

Formatted lower-cased with a space, it is not immediately apparent that 'map entry' is a term of art referring to a specific thing. 'map entry' might be mis-interpreted as a casual synonym for 'the entry of a map associated to a key', i.e., the value.

Proposal #1
Reword the find docstring to be more precise about what is returned.

Returns a clojure.lang.MapEntry containing key and the associated value, or nil if key not present.

Proposal #2
If you don't want to make a commitment to returning a MapEntry, reword to

Returns a sequential collection containing key and the associated value, or nil if key not present.

Why is `list` defined with a RestFn instead of `create` method?

Tue, 09 Dec 2025 15:18:48 +0000

Stemming from a conversation on slack, I learned that list is not a function created with fn* but an instance of the class clojure.lang.PersistentList$Primordial. This leads to inconsistencies, such as (vary-meta list assoc :hello :world) throwing an error instead of returning an AFunction with metadata. Reading through the git history, it looks like this approach was chosen very early (commit "made list return a PersistentList, not a seq").

Is there a reason why this approach was taken versus a create(ISeq args) overload like vector and hash-map?

not-found arg for invoking set (and vector)?

Sat, 06 Dec 2025 15:58:45 +0000

Is there a reason that sets (and vectors) don't have a not-found argument for invoke?

({:a :b} :c :not-found) ;;=> :not-found
user=> (#{:a :b} :c :not-found)
Execution error (ArityException) at user/eval1 (REPL:1).
Wrong number of args (2) passed to: clojure.lang.PersistentHashSet

In ClojureScript it's already implemented:

cljs.user=> (#{:a :b :c} :d :not-found)
:not-found

However not for vector:

cljs.user=>  ([] 0 :not-found)
Execution error (Error) at (<cljs repl>:1).
No item 0 in vector of length 0

If JIRA issue + patch is welcome for this, I'm volunteering.

clojure.edn and clojure allows keywords with empty ("") namespaces

Fri, 05 Dec 2025 09:56:54 +0000

Following links and snippets are about clojure.edn but because this logic is the same in clojure it also affects clojure reader as well.

Here is how symbol pattern is defined:

[:]?([\D&&[^/]].*/)?(/|[\D&&[^/]][^/]*)

It is eagerly matching prefix until the last slash character, after that it matches symbol name.

Then there is a wrong analysis of matched groups happen: ns is incorrectly set to everything until the last slash with validation that it is not ends with :/

Then in Symbol.intern call there is an another lookup for the first slash to split symbol into namespace and name.

The result is that keywords like this: ":/-/-", end up with namespace set to empty string "".

Looks like the least intrusive way to fix it is to use the same logic to find namespace borders in both places:

during symbol reading, lookup the first / to set ns instead of using the first matching group
in symbol interning the logic is correct

Another option is to use different regular expression:

[:]?([\D&&[^/]][^/]*/)?(/|[\D&&[^/]].*[^/])

This matches symbol prefix til the first slash keeping restriction "name can't end with slash".

Clojure Q&A - Recent questions in Clojure

Add assoc-some for constructing maps while skipping nil values

destructuring with :keys! and :or

require yields confusing "namespace ... not found after loading ..." error if masked by empty test file

Title

Environment

Description

Steps to Reproduce

Expected Behavior

Actual Behavior

Additional handling for `&` symbol in map destructuring for :keys/:syms/:strs could be a breaking change.

Will :keys! work with nested maps?

Namespaced map conversion fails when namespace keyword starts with a number

Possibly avoidable identity call to force instance method on Class literals

error printed using pprint in clojure 1.13.0-alpha1

Syntax-quoted lists can return nil, differs from ClojureScript

Why is aset at least 25 times faster than aset-long?

Why do literal vectors ignore type hinting?

Consider including a built-in wrapper around `java.net.http.HttpClient` in future versions of Clojure

Object.clone() confusion

Changing type tags can lead to cryptic errors

Request: allow a user function to be specified as the target of clojure.main/report-error

`eval` using functions with metadata

Should reduce-kv support String?

Consider allowing passing two arguments to sets used as functions

The behavior of `filter` on infinite sequences in Transducers

Can clojure builds be reproducible? (new Debian forky requirement)

`(:k m)` returns `nil` while `(identical? (first (keys m)) :k)` is `true` — two coexisting `Keyword` instances?

Environment

Questions

Reflection warning when long hint on an argument

"Nested" vs "lateral" exception causes

Destructuring {:as opts} unexpected behaviour with seq

Optimize `eduction`

Problem statement

Proposal

requiring an empty .clj without an alias should fail as with an alias

Is taggedliteral's equality check inefficient?

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

Controlled Bailout, Jira issue 2213

Idea: Exceptions

Idea: Like for/doseq

Idea: Using if-let

Idea: Threading macros

Final Words

Evaluating forms using eval can create a valid undesirable recursion point

Optimized str function

It's difficult to figure out options I can pass to slurp function.

Is it legal for a namespace to start with a number?

Feature Request:Make anonymous fn/reify class name IDs per namespace instead of one global counter

Is it valid for metadata to have metadata?

bit-count in cljs but not clj

definterface doesn't expose gen-interface's :extends for interface extension

How to force clojure.spec generator to skip a field

clojure.core/subs should use type hints of ^CharSequence, NOT ^String

Is invoking an anonymous primitive function expected to use the primitive interface?

Reader docs say foo.bar is a qualified symbol but qualified-symbol? is false

Literals for Unicode code points (and perhaps also sequences thereof)

CVE-warning in org.fressian/fressian <- org.clojure/data.fressian

Vulnerabilities

Why does the REPL incorrectly display my command after I press enter?

Octal escape sequence decoding in strings does not stop at non-octal digit

Aliased namespace in tagged literal

`find` docstring enhancement proposal

Why is `list` defined with a RestFn instead of `create` method?

not-found arg for invoking set (and vector)?

clojure.edn and clojure allows keywords with empty ("") namespaces

Idea: Using `if-let`