Clojure Q&A - Recent questions and answers

Answered: Why is clojure.core/derive not commutative?

Thu, 06 Aug 2026 14:07:33 +0000

I am falling into this trap as well.

There seems to be a reason for this check?

Answered: tools.reader project file version is outdated

Tue, 04 Aug 2026 13:58:22 +0000

Contrib libraries are built with Maven, not Leiningen. Any project.clj files were added by the individual maintainers, purely for their own convenience, and should not be relied on.

tools.build copy task does not respect non-replaced-exts

Sun, 02 Aug 2026 15:39:16 +0000

It is not possible to tell tools.build to copy files without substitution for a custom set of file extensions because the copy function does not actually use its parameter (non-replaced-exts) - it always uses default-non-replaced-exts:

(defn copy
  [{:keys [target-dir src-dirs include replace ignores non-replaced-exts]
    :or {include "**", ignores default-ignores, non-replaced-exts default-non-replaced-exts}
    :as _params}]
  (let [to-path (.toPath (file/ensure-dir (api/resolve-path target-dir)))
        ignore-regexes (map re-pattern ignores)
        non-replaced (map #(str "." %) default-non-replaced-exts)]
  ...)

The binding non-replaced-exts exists and defaults to default-non-replaced-exts but the function body never uses non-replaced-exts: it has default-non-replaced-exts hardcoded.

A new feature in the next version of deps-new depends on this working correctly.

Answered: Concurrency bug in tools.deps use of Aether/Maven libs?

Mon, 27 Jul 2026 22:04:28 +0000

In Clojure CLI 1.12.5.1664 I have moved tools.deps to use a single shared context/system/session instead of creating and caching one per thread. The previous mode was attempting to increase isolation when Maven was handling this poorly. In the newer version of these libs, they have made these interface support concurrency better and I believe this will be better.

Answered: Add assoc-some for constructing maps while skipping nil values

Mon, 27 Jul 2026 13:09:36 +0000

We have an existing jira for this idea at https://clojure.atlassian.net/browse/CLJ-2707

Answered: `(nth nil 10)` returns `nil` when it should throw

Wed, 22 Jul 2026 13:52:32 +0000

This is the expected behvaior (older ticket where this was considered is at https://clojure.atlassian.net/browse/CLJ-2029). nth, like get or contains? has polymorphic behavior on nil, and that is as intended. The docstring could probably be clarified.

JVM-parity bug in how :clojure.datafy/class is set in clojureCLR

Tue, 21 Jul 2026 06:27:09 +0000

As I was working on the magic compiler (the compiler to build to il2cpp in Unity), I noticed i was not having the same behaviour for datafy than clojureCLR.

In fact, we found a small JVM-parity bug in clojure.datafy/datafy, in how :clojure.datafy/class is set in ClojureCLR:

;; JVM clojure (datafy.clj) : fully qualified name, e.g. my.ns.CombinationB
(vary-meta v assoc ::obj x ::class (-> x class .getName symbol))

;; MAGIC's port : .FullName is the CLR equivalent of .getName, so same result
(vary-meta v assoc ::obj x ::class (-> x class .FullName symbol))

;; ClojureCLR (Clojure.Source/clojure/datafy.clj) : .Name is only the short name,
;; e.g. CombinationB, so the namespace is lost
(vary-meta v assoc ::obj x ::class (-> x class .Name symbol))

This breaks code that resolves the class back from the metadata (e.g. reconstructing records from datafied data ). The fix is small change: .Name → .FullName.

Answered: Possible bug in conditional with NaN comparison

Mon, 20 Jul 2026 14:29:43 +0000

It's definitely a bug. Will be fixed in the next release. (I'll have a new alpha out this week, but plan to do a GA release toward the end of the week.)

For those who like details:

It's a bug that only occurs when calling a one of <, <=, >, >= on two arguments in a context where both arguments have known types and the types are both double, and the context of the call is the test in a conditional. So only when we have something like (if (<= ^double x ^double y) ... ). And the generated code gives an incorrect answer only when one or both of the arguments is NaN.

Why? (Asks no one.)

Both the ClojureJVM and ClojureCLR compilers detect calls to numeric comparison operators as the test of a conditional and replace a static method call with an equivalent sequence of direct bytecode/MSIL instructions. The ClojureCLR code copied the comparator code for integer arguments when doing the double, which involved a negation. For integers, the negation of a <= is >. That is not true for doubles, when an argument is NaN. Brain cramp.

Answered: Implement ^:async (CLJS) for protocol functions and multi-methods

Sun, 19 Jul 2026 15:59:04 +0000

As this isn't going to be supported (yet) a workaround that you can use everywhere is:

((^:async fn [] ...your method body here...))

Answered: destructuring with :keys! and :or

Tue, 14 Jul 2026 20:13:00 +0000

Yes, this is as expected.

Note that pre-1.13, :or was a map of binding (unadorned symbol) to default value to be used if a bound key was missing. Any other key type had no meaning and was ignored. In 1.13, :or may contain literal keys that will be added to the :defaults map or be used to fill in the :select map (they have no other use).

1) No :defaults or :select, so :a is just ignored.

2) a is now bound and thus :a is required. Because of this, there is no possibility to use :a from :or in :defaults or :select, so this is now an error.

3) Again, :b is not needed for :defaults or :select, so ignored (really same as #1).

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

Tue, 14 Jul 2026 01:43:38 +0000

I realize that I made a mistake, the test file should have been named llm_test.clj instead of llm.clj. Nevertheless the compiler error message could be more user-friendly, perhaps by including the full path to the problematic file.

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

Thu, 09 Jul 2026 15:57:10 +0000

Yes, the intent here is to carve this out of being allowed so it is available for syntax purposes in destructuring. We did a fair amount of searching and do not see this being used anywhere.

We've updated the reference page at https://clojure.org/reference/reader#_symbols to explicitly note this.

Browser REPL on different port

Wed, 08 Jul 2026 07:16:39 +0000

Clojurescript's built-in browser REPL is on port 9000 by default but that clashes with ZScaler on my work laptop so I use port 8090 instead. It took a few goes to get it working but now I have it sorted.

clojure -M -m cljs.main -v -p 8090 -co '{:closure-defines {"clojure.browser.repl.PORT" 8090}}' -c foo.core -r

There are some points in the documentation that might benefit from clarification. The -p flag is not mentioned on The REPL and main entry points but seems to serve the same purpose as :port described on REPL Options because this also works:

clojure -M -m cljs.main -v -ro '{:port 8090}' -co '{:closure-defines {"clojure.browser.repl.PORT" 8090}}' -c foo.core -r

What is a little bit surprising is that :port is only mentioned under the Node REPL Options section but applies to browser REPLs too.

Not really a question in all this but I wanted to share this for others who might get stuck.

Versions for posterity: Clojure CLI version (deps.clj) 1.12.2.1565 on Windows 11 and ClojureScript 1.11.54.

Answered: Will :keys! work with nested maps?

Mon, 06 Jul 2026 16:08:02 +0000

If we try that code in a REPL, we see that it complains about :e being missing:

user=> (let [sample-map {:a 1 :b {:a 2 :b 3 :c 4 :d 42}}
             {a :a {aa :a :as m :keys! [b c & d e]} :b} (dissoc sample-map :c)] b)
Execution error (IllegalArgumentException) at user/eval126 (REPL:1).
Missing required key: :e

But the test is weird because sample-map doesn't actually have a :c key at the top level, only nested under :b.

In answer to your overall question, yes, :keys! works anywhere that :keys already works, and that includes nested map destructuring.

Here's an example from our code at work:

  [{:keys! [worldsingles-application members actioner database]
    {:keys! [& redis-pubsub] pubsub :redis-pubsub} :worldsingles-application
    :as service}]

This checks that :redis-pubsub is a key under :worldsingles-application which is a key of service, but does not bind redis-pubsub, and also binds pubsub to the :redis-pubsub key. Yes, we have Alpha 2 in production and this code used to be multiple let bindings and explicit checks for keys being present.

Weird install paths can break linux-install.sh or posix-install.sh scripts

Mon, 06 Jul 2026 15:46:10 +0000

I'm trying to install clojure from the official installer for once, instead of my old "install lein from apt" method -- I wanted the official tool CLIs.

$ curl -L -O https://github.com/clojure/brew-install/releases/latest/download/linux-install.sh
(completes)
$ chmod u+x linux-install.sh 
$ ./linux-install.sh --prefix "$HOME/.local"
Downloading and expanding tar
clojure-tools-1.12.5.1654.tar.gz: OK
Installing libs into /home/fgabolde@/.local/lib/clojure
Installing clojure and clj into /home/fgabolde@/.local/bin
sed: -e expression #1, char 25: unknown option to `s'

Undeterred, I go back to the docs and find a "POSIX" installer. Aha! That must be it. The other installer assumed something about my shell environment and this one must be written to POSIX specs and that will fix everything!

I download posix-installer.sh, do the same dance, and exactly the same happens.

At this point I remember that when this machine was provisioned, IT made a typo and my homedir is /home/fgabolde@ for no good reason. This has tripped up other programs before. And indeed, the sed invocations in the install script use @ as a delimiter, so my weird homedir terminates the replacement string early.

I fixed it by changing the delimiters in the install script and rerunning.

Answered: Namespaced map conversion fails when namespace keyword starts with a number

Mon, 06 Jul 2026 15:27:22 +0000

It looks like Clojure has no problem with either :0 or :0/a

It does, it just doesn't complain - there are very few explicit checks and in general it's GIGO (garbage in, garbage out).

From https://clojure.org/reference/reader:

Symbols begin with a non-numeric character [...] [...]
Keywords are like symbols [...]

Answered: Changing type tags can lead to cryptic errors

Fri, 03 Jul 2026 00:06:18 +0000

It might be useful for the compiler to give a warning when a var is redefined such that it loses a primitive interface.

We could still detect these changes without compiler changes like this:

Clojure 1.12.5
user=> (defn f ^long [^long a] a)
#'user/f
user=> (add-watch #'f ::undo-prim (fn [_ _ old new] (when (and (instance? clojure.lang.IFn$LL old) (not (instance? clojure.lang.IFn$LL new))) (println "WARNING: removed clojure.lang.IFn$LL from f"))))
#'user/f
user=> (defn f [a] a)
WARNING: removed clojure.lang.IFn$LL from f
#'user/f

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.

Answered: how to run a clojurescript repl

Wed, 17 Jun 2026 14:35:29 +0000

This is covered in the QuickStart https://clojurescript.org/guides/quick-start and there is a REPL category under Reference same as clojure.org.

Anything we could do that would make this easier for you to find?

Answered: clj risk of automatic dependency update causing RCE

Tue, 16 Jun 2026 20:30:50 +0000

There is no code execution performed during dependency downloads. So, done.

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

Mon, 15 Jun 2026 17:05:19 +0000

We’ve spent a bunch of time on this and got into some surprising places with it. I am very much hoping all these set functions will be rewritten in next release.

Answered: Why do literal vectors ignore type hinting?

Sun, 14 Jun 2026 23:09:31 +0000

Literal collections are tagged as IPersistentVector, IPersistentMap, etc and as constant expressions won’t preserve type hints. It is better here to use the new qualified method syntax with param-tags hints if needed.

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

Answered: Object.clone() confusion

Sat, 06 Jun 2026 00:06:59 +0000

clone() is a protected method - you should generally not call it on an arbitrary object. In Java, you can't even make that call, you'll get "clone() has protected access in java.lang.Object". It's a quirk of Clojure's impl that it even makes it possible via reflection.

So, my suggestion is to not call clone() at all. There are many, many reasons clone() is problematic and considered one of the more questionable features of Java's early design.

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.

Answered: :or destructuring doesn't update object

Mon, 01 Jun 2026 17:45:30 +0000

I logged an improvement request for this here, happy to collect more ideas here.

https://clojure.atlassian.net/browse/CLJ-2957

Answered: `eval` using functions with metadata

Mon, 01 Jun 2026 16:31:28 +0000

You're eval'ing + to a function object there when it seems like you should be staying in symbol land:

user=> (eval (list (with-meta '+ {}) 1 2))
3

A function object itself is not Clojure data (other than opaquely as an object). When working symbolically, you should stay in symbols.

There are some places where the compiler uses an escape hatch of print + read-eval (#=) to recover custom types (sorted maps and sets), but I'd consider that implementation details, not something you as a user should be doing generally.

Answered: Should reduce-kv support String?

Fri, 29 May 2026 21:21:22 +0000

Interesting idea! Logged as https://clojure.atlassian.net/browse/CLJ-2956

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

Answered: gitlibs/tags throws a NPE if the repository has no tags

Sun, 24 May 2026 21:02:21 +0000

Thanks! Fixed in tools.gitlibs 2.6.217.

Answered: The behavior of `filter` on infinite sequences in Transducers

Sun, 24 May 2026 08:31:02 +0000

take converts its collection argument into a seq, and making a seq out of an eduction is done via the java.lang.Iterable route. That route moves the data around in chunks of size 32. So (take ... (eduction ...)) will try to fetch 32 elements regardless of the number passed to take.

So, it's not about transducers, it's about how eduction and converting it into a seq work.

You'll see the same behavior with sequence - but that's because it creates a chunked sequence internally.

Answered: Can 'write-pom' in tools.build support providing additional dependencies in the pom.xml with scope 'provided'?

Thu, 21 May 2026 21:36:50 +0000

tools.build supports :optional true in a dependency, which adds <optional>true</optional> to pom.xml and https://cljdoc.org fetches the dependency, so analysis works, but the dependency does not get pulled in as a transitive dep for "normal" project usage.

See my rephrase project for an example of this working:

https://github.com/seancorfield/rephrase/blob/main/deps.edn#L4-L6

:aliases {:optional {:extra-deps {nrepl/nrepl {:mvn/version "1.7.0" :optional true}}} ...

https://github.com/seancorfield/rephrase/blob/main/build.clj#L34

:basis (b/create-basis {:aliases [:optional]})

(used for the write-pom call)

Doesn't show up when used via deps.edn:

clojure -Spath -Sforce -Sdeps '{:deps {org.corfield/rephrase {:mvn/version "1.0.2"}}}' src:/home/sean/.m2/repository/org/clojure/clojure/1.12.5/clojure-1.12.5.jar:/home/sean/.m2/repository/org/corfield/rephrase/1.0.2/rephrase-1.0.2.jar:/home/sean/.m2/repository/org/clojure/core.specs.alpha/0.4.74/core.specs.alpha-0.4.74.jar:/home/sean/.m2/repository/org/clojure/spec.alpha/0.5.238/spec.alpha-0.5.238.jar

Answered: core.unify does not preserve want-occurs? in recursive unify-variable calls

Tue, 19 May 2026 20:32:36 +0000

Thanks for the report. Definitely not intentional.

Logged at https://clojure.atlassian.net/browse/UNIFY-12

Answered: linux installer fails for non english locale

Tue, 19 May 2026 19:59:16 +0000

Logged as https://clojure.atlassian.net/browse/TDEPS-280, definitely will fix!

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

Tue, 19 May 2026 19:56:55 +0000

Reproducible compilation is not currently a priority for us. But happy to leave this open to hear more reasons why that is important and collect votes.

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

Mon, 11 May 2026 16:12:27 +0000

It might also be interesting to know if you are getting a null due to not-found key vs null value in the map. You could supply a not-found arg on (:payload result :NOT-FOUND) to distinguish.

Have you recently updated Clojure?

Is this problem reproducible such that you could try it again with different code, deps, etc?

Keyword invocation uses special call sites and the compiler code for that changed in Clojure 1.12.3, so I would be interested in whether the behavior changes if you use Clojure 1.12.2.

Or alternately, does the behavior change if you modify the code from (:payload result) to (get result :payload).

Answered: Reflection warning when long hint on an argument

Fri, 01 May 2026 21:12:15 +0000

It's the same thing as in https://ask.clojure.org/index.php/13501/primitive-type-hints-arguments-turns-the-return-value-object.

Default implementation of AsElements to treat numbers as numbers, not strings

Tue, 28 Apr 2026 16:10:26 +0000

I'm slowly converting some code from using xml/element to xml/sexp-as-element, and I've noticed a discrepancy. xml/element does (almost) no processing of the "content", inserting it directly (unless it's nil). xml/sexp-as-element calls (str) on the "content" if it's not seq of some kind (vector or ISeq) or a keyword. This means that (= (xml/element :foo {} 1) (xml/sexp-as-element [:foo 1])) is false.

There are probably other differences, but this one seems relatively big, as there's no way to use numbers in xml/sexp-as-element without calling extend-protocol yourself.

May I recommend/request adding this extension? It will make xml/sexp-as-element match xml/element for numbers, and make xml/sexp-as-element match hiccup in general.

(extend-protocol clojure.data.xml.protocols/AsElements
  java.lang.Number
  (as-elements [n] [n]))

Answered: Installing Clojure on IPv6-only machine

Sat, 25 Apr 2026 00:45:08 +0000

I haven't double-checked this but it seems that repo1.maven.org is IPv4-only, so you can't download artifacts from your IPv6-only server.

However, Sonatype offer https://ipv6.repo1.maven.org/maven2 for IPv6.

I don't know whether you can override the Maven Central URL that the Clojure CLI uses -- because it knows about Maven and Clojars internally and checks them in order first, for security reasons.

Hopefully, Alex will chime in on this.

Answered: Porting .NET 4.8 application using Clojure CLR to .NET 8

Thu, 23 Apr 2026 04:55:40 +0000

clojure.core/load calls RT.load as seen in the stack trace.
The set of probe paths for RT.load is

the directory of the domain of the thread that is running (domains really being more relevant to .NET Framework at this point)
the current directory
the directory where Clojure.dll is located
the directory of the entry assembly
all directories listed as the value of the environment variable CLOJURE_LOAD_PATH
- this is equivalent to the classpath in Java-land.
- separator character is System.IO.Path.PathSeparator (; on Windows)

Clearly this is not sufficiently documented. Will work on that.

Answered: Does Clojure have an anti LLM code contributions policy? Would it make sense for Clojure to adopt one?

Mon, 06 Apr 2026 13:24:09 +0000

We've added a statement in this regard to several pages on the site to clarify what is allowed under the Clojure contributor agreement.

https://clojure.org/dev/contributor_agreement#_no_generated_code

Answered: Optimize `eduction`

Sun, 05 Apr 2026 21:50:04 +0000

Logged as https://clojure.atlassian.net/browse/CLJ-2953

Answered: "Nested" vs "lateral" exception causes

Sun, 05 Apr 2026 21:46:32 +0000

I'm not sure this problem is common enough to warrant solving in core or extending the existing ex-info. If you are trying to throw a map bundling multiple exceptions, this really seems like a data problem more than an exception problem, and we have plenty of ways to bundle data into the ex map.

In Java, the typical solution for (one) lateral exception is to use ExecutionException, doesn't handle multiple though.

Answered: Destructuring {:as opts} unexpected behaviour with seq

Sun, 05 Apr 2026 02:22:50 +0000

A lot of this can be broadly considered "garbage-in, garbage-out". {:as opts} is map destructuring and so if you give it a non-map, you'll get undefined behavior.

In particular, try these expressions on Clojure 1.10 and you'll see that many of them throw exceptions.

Clojure 1.11 introduced a new meaning for some key/value destructuring -- see https://clojure.org/news/2021/03/18/apis-serving-people-and-programs -- which changed the undefined behavior, in order to support new use cases.

Bottom line: pass a non-map to map destructuring and you are in undefined behavior territory. It just happened to change between 1.10 and 1.11 so that some cases that threw exceptions now just produce "junk" instead.

Missing protocol error will hang on infinite `(range)` input in ClojureScript but not Clojure

Fri, 03 Apr 2026 11:16:47 +0000

functions like transient, assoc, etc will throw helpful missing-protocol error when receiving invalid input but it will hang if it receives infinite (range).
this is related to issue below
https://ask.clojure.org/index.php/14578/even-range-hangs?show=14578#q14578

however, missing-protocol only hang in clojurescript but not clojure so I am wondering if this difference is intended.

example calls that should throws
- (transient (range))
- (assoc (range) :a 1)

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

Thu, 02 Apr 2026 20:41:10 +0000

Logged:
https://clojure.atlassian.net/browse/CLJ-2951

And one for compile:
https://clojure.atlassian.net/browse/CLJ-2952

Answered: Is taggedliteral's equality check inefficient?

Tue, 31 Mar 2026 19:58:35 +0000

Logged as https://clojure.atlassian.net/browse/CLJ-2950

Answered: Optimized str function

Sun, 29 Mar 2026 08:47:19 +0000

I've done some independent exploration of the options space for optimizing str which does not involve anything ground shattering but still gives good performance improvements

variadic arities (up to 20, yuck) will probably give the best performance. Can settle for common cases like up to 5 (apply str will still suck but whatever)
using reduce instead of a loop (would probably require redefining str or providing a str1 with the old impl for bootstrap purposes)
using inline meta, orthogonal to all other options

Additionally, having a function like str which only takes a sequence and reduces over it could provide a better code path than (apply str xs)

Similar work has been done in spork and stringer