Clojure Q&A - Recent questions

tools.reader project file version is outdated

Tue, 04 Aug 2026 02:36:36 +0000

Hello! I noticed version currently defined in the tools.reader project.clj file is out of date with respect to the latest git tag. Would it be possible to keep those in sync? This situation is making packaging the library for Debian a bit more complicated than it needs to be. Thanks!

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.

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

Wed, 22 Jul 2026 03:30:47 +0000

The doc string for nth reads:

clojure.core/nth
([coll index] [coll index not-found])
Returns the
value at the index. get returns nil if index out of bounds, nth
throws an exception unless not-found is supplied. nth also works
for strings, Java arrays, regex Matchers and Lists, and, in O(n)
time, for sequences.

The behavior agrees when the coll is [] or '() or other empty collections. However:

user=> (nth [] 10) Execution error (IndexOutOfBoundsException) at user/eval280 (REPL:1). null user=> (nth nil 10) nil

Trying to get the 10th item of [] throws but trying to get the 10th item of nil returns nil.

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

Tue, 21 Jul 2026 18:08:46 +0000

Occasionally, I've been seeing this error:

[org.eclipse.aether.internal.impl.DefaultTrackingFileManager] [] {} Failed to read tracking file '/home/sean/.m2/repository/org/apache/maven/maven/3.8.8/_remote.repositories' java.nio.channels.ClosedChannelException

which leads to

Expected HashMap$TreeNode, but was given HashMap$Node, at java.util.HashMap$TreeNode/moveRootToFront (HashMap.java:2020) - runtime error (unexpected type).

And the only solution seems to be to blow away part of the ~/.m2/repository and use -Sforce to recompute/redownload.

Any idea what might cause this sort of error? (Windows/WSL2, Ubuntu 20.04, all the very latest CLI/Clojure etc). See Slack thread for more discussion: https://clojurians.slack.com/archives/C6QH853H8/p1784653752175769

More of the stacktrace:
`
at java.base/sun.nio.ch.FileChannelImpl.ensureOpen(FileChannelImpl.java:169)

    at java.base/sun.nio.ch.FileChannelImpl.lock(FileChannelImpl.java:1676)
    at org.eclipse.aether.internal.impl.DefaultTrackingFileManager.fileLock(DefaultTrackingFileManager.java:171)
    at org.eclipse.aether.internal.impl.DefaultTrackingFileManager.read(DefaultTrackingFileManager.java:65)
    at org.eclipse.aether.internal.impl.EnhancedLocalRepositoryManager.readRepos(EnhancedLocalRepositoryManager.java:220)
    at org.eclipse.aether.internal.impl.EnhancedLocalRepositoryManager.checkFind(EnhancedLocalRepositoryManager.java:151)
    at org.eclipse.aether.internal.impl.EnhancedLocalRepositoryManager.find(EnhancedLocalRepositoryManager.java:128)
    at org.eclipse.aether.internal.impl.DefaultArtifactResolver.resolve(DefaultArtifactResolver.java:360)
    at org.eclipse.aether.internal.impl.DefaultArtifactResolver.resolveArtifacts(DefaultArtifactResolver.java:261)
    at org.eclipse.aether.internal.impl.DefaultArtifactResolver.resolveArtifact(DefaultArtifactResolver.java:243)
    at org.apache.maven.repository.internal.DefaultModelResolver.resolveModel(DefaultModelResolver.java:158)
    at org.apache.maven.repository.internal.DefaultModelResolver.resolveModel(DefaultModelResolver.java:204)
    at org.apache.maven.model.building.DefaultModelBuilder.readParentExternally(DefaultModelBuilder.java:1035)
    at org.apache.maven.model.building.DefaultModelBuilder.readParent(DefaultModelBuilder.java:827)
    at org.apache.maven.model.building.DefaultModelBuilder.build(DefaultModelBuilder.java:336)
    at org.apache.maven.model.building.DefaultModelBuilder.build(DefaultModelBuilder.java:248)
    at org.apache.maven.repository.internal.DefaultArtifactDescriptorReader.loadPom(DefaultArtifactDescriptorReader.java:293)
    at org.apache.maven.repository.internal.DefaultArtifactDescriptorReader.readArtifactDescriptor(DefaultArtifactDescriptorReader.java:183)
    at org.eclipse.aether.internal.impl.DefaultRepositorySystem.readArtifactDescriptor(DefaultRepositorySystem.java:269)
    at clojure.tools.deps.extensions.maven$read_descriptor.invokeStatic(maven.clj:117)
    at clojure.tools.deps.extensions.maven$read_descriptor.invoke(maven.clj:108)
    at clojure.tools.deps.extensions.maven$eval61086$fn__61087.invoke(maven.clj:148)

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.

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

Sun, 19 Jul 2026 11:53:45 +0000

In ClojureScript (as of 1.12.145) one can declare a function (defn, fn) to be async by adding the metadata ^:async. However, the same is not applicable to protocol functions and multi-methods. Since async is an invocation semantic, should it be carried over to protocol functions and multimethods? (If yes, should it apply to the protocol definition in defprotocol or to the protocol implementation in reify?)

If async is not to be allowed in protocol functions and multimethods, then the documentation should clearly mention the omissions, alternatives and workaround.

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}

; f returns nil
(assoc-some {:a 1} :b (f))
;; => {: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 third 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

Possible bug in conditional with NaN comparison

Sat, 11 Jul 2026 15:01:23 +0000

I encountered this possible bug while running a property-based test suite in a ClojureCLR project. Given a comparison between NaN in an if expression, it seemingly takes the wrong branch.

Clojure (CLR)

λ cljr
Clojure core loaded in 837 milliseconds.
Starting main
Clojure core loaded in 409 milliseconds.
Clojure 1.12.2
user=> (<= ##NaN ##NaN)
false
user=> (if (<= ##NaN ##NaN) true false)
true
user=> (let [t (<= ##NaN ##NaN)] (if t true false))
false

user=> (>= ##NaN ##NaN)
false
user=> (if (>= ##NaN ##NaN) true false)
true
user=> (let [t (>= ##NaN ##NaN)] (if t true false))
false

I wasn't able to replicate the issue on Clojure (JVM), C#, or F#.

Clojure (JVM)

λ clj
Clojure 1.12.0
user=> (<= ##NaN ##NaN)
false
user=> (if (<= ##NaN ##NaN) true false)
false
user=> (let [t (<= ##NaN ##NaN)] (if t true false))
false

using System;
					
public class Program
{
	public static void Main()
	{
		Console.WriteLine(Double.NaN <= Double.NaN);
		if (Double.NaN <= Double.NaN) {
			Console.WriteLine(true);
		} else {
			Console.WriteLine(false);
		}
		var t = Double.NaN <= Double.NaN;
		if (t) {
			Console.WriteLine(true);
		} else {
			Console.WriteLine(false);
		}
	}
}

False
False
False

λ dotnet fsi

> nan <= nan;;                                                                
val it: bool = false

> if (nan <= nan) then true else false;;                          
val it: bool = false

> let t = nan <= nan;;
val t: bool = false

> if t then true else false;;
val it: bool = false

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

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.

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.

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.

clj risk of automatic dependency update causing RCE

Tue, 16 Jun 2026 08:16:29 +0000

I think we should consider enforcing some mechanism to prevent automatic, ai-induced dependency downloading to enable abusers to cause automatic execution of arbitrary code any time a user of AI updates any dependency graph.

NPM is currently getting abused frequently via this vector.

NPM has the unfortunate aspect that when you run npm install it will enable code execution of code provided by a third-party.

In the age of AI, a hacker could pose as a library useful for something, and do remote code execution via the ability to do something seemingly innocuous and very common in a workplace environment.

Corporate sabotagists could easily take advantage of this mechanism of compromise and infiltrate common corporate environments.

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?

how to run a clojurescript repl

Fri, 12 Jun 2026 19:52:36 +0000

I've used planck occasionally for years, but now it seems to be deprecated. (Won't build on homebrew.) But it sounds like its functionality has been absorbed by clj. So where can I find documentation about this, and how to run a cljs REPL?

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)

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

Fri, 22 May 2026 15:59:50 +0000

Using:

org.clojure/tools.gitlibs     {:mvn/version "2.6.212"}

This throws NPE

(gitlibs/tags "https://github.com/clojure/clojure-site.git")

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

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

Sat, 16 May 2026 19:09:05 +0000

core.unify does not preserve want-occurs? when recursing from unify-variable-. That is, if unify-varable- calls garner-unifiers, it does not pass itself as the uv-fn parameter, so garner-unifiers will default to unify-variable (which includes an occurs? check). I'm not sure if this was intentional, but I found it surprising. If not intentional, then I believe calls to garner-unifiers in create-var-unification-fn should look like:
(garner-unifiers ~'var-unify ~varp vb# ~expr ~binds)

linux installer fails for non english locale

Thu, 14 May 2026 20:48:19 +0000

"OK" returned by sha256sum may be translated. Better rely on the exit status. Since -p pipefail is used, the pipe to grep could be simply omitted.

`(: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!

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]))

Installing Clojure on IPv6-only machine

Fri, 24 Apr 2026 23:21:53 +0000

Since GitHub (still) do not support IPv6 it is not possible to follow the instructions at https://clojure.org/guides/install_clojure (for Linux, say) to install the Clojure CLI on a machine running ONLY IPv6 (in this case Hertzner).

When downloading the .tar.gz-file manally and uploading it directly, installing the CLI tools is possilbe.

The problems seem to continue installing common clojure dependencies, like data.json 2.5.2, which leads to this:

clj -X:server
Error building classpath. Failed to read artifact descriptor for org.clojure:data.json:jar:2.5.2
org.eclipse.aether.resolution.ArtifactDescriptorException: Failed to read artifact descriptor for org.clojure:data.json:jar:2.5.2
	at org.apache.maven.repository.internal.DefaultArtifactDescriptorReader.loadPom(DefaultArtifactDescriptorReader.java:255)
	at org.apache.maven.repository.internal.DefaultArtifactDescriptorReader.readArtifactDescriptor(DefaultArtifactDescriptorReader.java:171)
	at org.eclipse.aether.internal.impl.DefaultRepositorySystem.readArtifactDescriptor(DefaultRepositorySystem.java:263)
	at clojure.tools.deps.extensions.maven$read_descriptor.invokeStatic(maven.clj:115)
	at clojure.tools.deps.extensions.maven$fn__1340.invokeStatic(maven.clj:143)
	at clojure.tools.deps.extensions.maven$fn__1340.invoke(maven.clj:143)
	at clojure.lang.MultiFn.invoke(MultiFn.java:244)
	at clojure.tools.deps$expand_deps$children_task__959$fn__961$fn__962.invoke(deps.clj:299)
    ...
Caused by: java.net.SocketException: Network is unreachable
at java.base/sun.nio.ch.Net.connect0(Native Method)
at java.base/sun.nio.ch.Net.connect(Net.java:546)
at java.base/sun.nio.ch.Net.connect(Net.java:535)
at java.base/sun.nio.ch.NioSocketImpl.connect(NioSocketImpl.java:585)
at java.base/java.net.SocksSocketImpl.connect(SocksSocketImpl.jar

All this seem a bit bisarre of course. Workarounds would make me happy!

"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))))

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)

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

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

Sun, 29 Mar 2026 13:14:25 +0000

LLM use appears to have a bunch of ethical and practical problems, the most pressing one seems to be the plagiarism that seems to be pretty excessive even for code and even when not baited:

Video clip of apparently a lawyer live demoing what seems to be Co-Pilot plagiasm

I don't know anything about law, but the lawyer at one point says: "This is a copyright infringement." I've also found this: https://www.twobirds.com/en/insights/2025/landmark-ruling-of-the-munich-regional-court-(gema-v-openai)-on-copyright-and-ai-training It seems to talk about "fair use" of AI model training.

Also see this high-profile incident: https://www.pcgamer.com/software/ai/microsoft-uses-plagiarized-ai-slop-flowchart-to-explain-how-github-works-removes-it-after-original-creator-calls-it-out-careless-blatantly-amateuristic-and-lacking-any-ambition-to-put-it-gently/

Also this field study that appears to be putting the plagiarism rate at seemingly at least 2-5%: https://dl.acm.org/doi/10.1145/3543507.3583199

This article mentions a study that apparently puts the plagiarism rate at 8–15% as a minimum for the easily detectable kind: https://www.theatlantic.com/technology/2026/01/ai-memorization-research/685552/

I don't know what this means legally, but at least morally and ethically this seems sad.

Apparently, some people in the Clojure space already spoke out against LLMs, but I wasn't able to find any anti LLM policy. If there was such a policy, I would expect it to be mentioned in the following places:

I simply wanted to suggest that perhaps the project may want to adopt such a policy.

Here are some other projects that have already done so: Asahi Linux, elementaryOS, Forgejo, Gedit, Gentoo, GIMP, GoToSocial, Löve2D, Loupe, NetBSD, postmarketOS, Qemu, RedoxOS, Servo, stb libraries, Zig.

My deepest apologies if there already is such a policy, or if I'm asking in the wrong space.

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.

Is the recent change to flow's futurize safe?

Tue, 17 Mar 2026 15:54:00 +0000

Previously flow's futurize would rethrow any exceptions thrown by the function when deref'ed. With the recent changes to return a CompletableFuture it no longer does that and instead if the function throws deref'ing will just hang forever.

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

Clojure Q&A - Recent questions

tools.reader project file version is outdated

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

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

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

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

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

Add assoc-some for constructing maps while skipping nil values

destructuring with :keys! and :or

Possible bug in conditional with NaN comparison

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.

Browser REPL on different port

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

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

clj risk of automatic dependency update causing RCE

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

Why do literal vectors ignore type hinting?

how to run a clojurescript repl

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

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

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

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

linux installer fails for non english locale

`(: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

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

Installing Clojure on IPv6-only machine

"Nested" vs "lateral" exception causes

Destructuring {:as opts} unexpected behaviour with seq

Optimize `eduction`

Problem statement

Proposal

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

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

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

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

Is the recent change to flow's futurize safe?

Evaluating forms using eval can create a valid undesirable recursion point

Optimized str function

Idea: Using `if-let`