Clojure Q&A - Recent activity in Clojure

Commented: Checked behavior in 1.13 destructuring outside of `:keys!` like directives

Thu, 15 Oct 2026 14:53:32 +0000

Thanks Sean, I didn't see your example on slack. However it clicked for me when Alex told me I can use both renaming and `:keys! [& ...]` with the same symbols. You can have your aliases made outside directives and check them using `:keys!`.

This way the current implementation can do everything I describe -- except for the bad good idea of putting keywords in vars -- without adding new directives. Quite neat.

Commented: Bytecode not 100% deterministic given identical inputs?

Wed, 16 Sep 2026 22:56:19 +0000

I've ran into similar problem, and it doesn't stop at the issue you described - RT.nextID() calls in gensym etc. inherently depend on global state.

I do both AOT compiled class deployment to speed up loading Clojure code + implement hotfixes in production. Evaluating code at runtime where there has been less or more RT.nextID() calls causes interesting NoClassDefFoundError to pop up.

Closed: Why gen-class does not generate default interface methods?

Wed, 02 Sep 2026 18:32:21 +0000

When using gen-class, the generated .class doesn't have the default methods from java interfaces.

I created this repro, you can confirm a exception is throw when trying to call the method from the generated class from gen-class:

clj -T:build jar to generate the classes at target/classes
java -cp clj -Spath client/main/Main.java

A exception is throw:

Exception in thread "main" java.lang.UnsupportedOperationException: otherthing (clojure-sample.foo/-otherthing not defined?)
    at clojure_sample.Foo.otherthing(Unknown Source)
    at client.main.Main.main(Main.java:9)

The not ideal workaround is to add the default method in the namespace implementing what is done in the default method inside the java interface.

Commented: Approach to case tableswitch may consume significant bytecode space

Sun, 30 Aug 2026 21:58:52 +0000

Per https://www.clojure.org/community/contributing#_reporting_problems_and_requesting_enhancements ask.clojure.org is the place to discuss issues. Jira is specifically for contributors. That page overall discusses the whole process.

Answered: Some core predicates aren't generic over all types

Mon, 24 Aug 2026 14:32:48 +0000

I don't think that we can change the behavior of those predicates since code may rely on the throw. However, docstring updates could help with clarifying what happens when the preds are called with values that might throw.

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

Sun, 09 Aug 2026 14:50:49 +0000

Alex has mentioned the Jira ticket around assoc-some, but I'll also note—because I missed it at first—that 1.13 has introduced some-vals which produces a map without nil-valued keys (and can be used as a predicate, since if there are no non-nil-valued keys, you get back nil rather than {}):

user=> (defn f [] nil)
#'user/f
user=> (def m {:a 1})
#'user/m
user=> (some-vals (assoc m :k (f)))
{:a 1}

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

Fri, 07 Aug 2026 01:06:36 +0000

This probably should have been a comment on the original question—it isn't an answer to the question.

Edited: destructuring with :keys! and :or

Mon, 03 Aug 2026 21:18:14 +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

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

Thu, 23 Jul 2026 17:26:59 +0000

In general, there is a philosophy in Clojure core functions of aggressive polymorphism - making different types of collection (or nil) do something useful. For collection retrieval functions in particular, returning nil (rather than throwing) allows you to chain retrievals through deep data structures and bottom out at nil via the various "some" functions (like `some->`) OR to do nil-punning conditional logic on nil.

I've logged as https://clojure.atlassian.net/browse/CLJ-2971

Closed: When using remote prepl server, repl is false, preventing use of add-lib and related functions

Tue, 21 Jul 2026 19:32:37 +0000

To reproduce:

clojure -J-Dclojure.server.jvm="{:port 5555 :accept clojure.core.server/io-prepl}"

Clojure 1.12.0
user=>

then

nc localhost 5555
*repl*
{:tag :ret, :val "false", :ns "user", :ms 0, :form "*repl*"}

Closed: Improve javadoc especially for tool usage

Tue, 21 Jul 2026 19:31:26 +0000

In order to provide a hot key in VS Code to show the JavaDocs associated with a selected form (class name or the type of an expression), I wrote the following Joyride script:

https://github.com/seancorfield/vscode-calva-setup/blob/develop/joyride/scripts/javadoc.cljs#L15

This highlights three issues that could be addressed/improved:

On JDKs later than 15, the javadoc machinery falls back to JDK 8, unless you explicitly call add-remote-javadoc for at least java. and javax.. This is a known issue that should be addressed in Clojure 1.13 per https://clojure.atlassian.net/browse/CLJ-2920 -- hopefully it will assume the URL structure for JDKs going forward so we don't run into this problem again, unless Oracle changes their URL structure again (hopefully, unlikely).
javadoc-url is private so tools have to use #' to access it, which makes it feel like this is just an implementation detail and subject to change. It would be nice for tools if this was part of the public, documented API for clojure.java.javadoc.
Inner classes are not handled well. If you ask for the javadoc-url for java.util.Map$Entry, you get a URL with Map$Entry.html which doesn't exist. Since inner classes are documented in their outer class, removing $[a-zA-Z0-9_]+ from the class name or from the URL would really help here.

Here's an example REPL session for Clojure 1.12.2 on JDK 24, showing these issues:

user=> (clojure-version) "1.12.2" user=> (require 'clojure.java.javadoc) nil user=> (#'clojure.java.javadoc/javadoc-url "java.util.concurrent.ExecutionException") "http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ExecutionException.html" user=> (#'clojure.java.javadoc/javadoc-url "java.util.Map$Entry") "http://docs.oracle.com/javase/8/docs/api/java/util/Map$Entry.html" user=>

Commented: Support for automatic promotion to BigDecimal in +', *', etc.

Tue, 14 Jul 2026 03:49:51 +0000

It’s in the queue for 1.13

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.

Commented: Somewhat confusing sorted-set behavior

Mon, 13 Jul 2026 21:49:41 +0000

This issue bites us at least once or twice a year. The latest one is `(dissoc a-sorted-map :foo)`, which throws when `a-sorted-map` doesn't contain `:foo` instead of just returning `a-sorted-map` unchanged. A fix would be highly appreciated.

"Use a different comparator" is often not an option because the sorted-map can come from code outside your control.

Our workaround is using `(into (empty x) (remove #(= :foo (key %)) x)` instead of `dissoc`

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

Thu, 09 Jul 2026 16:08:08 +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.

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

Mon, 06 Jul 2026 21:14:56 +0000

It is not valid Clojure, but it is not rejected in all situations, so it should not be relied on. There are some widely used Clojure libraries out there that assume it is not rejected in certain situations, so banning it is problematic—but also do not expect any changes that make it more widely accepted.

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.

Closed: error printed using pprint in clojure 1.13.0-alpha1

Fri, 03 Jul 2026 17:10:34 +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

Commented: Possibly avoidable identity call to force instance method on Class literals

Fri, 03 Jul 2026 17:09:38 +0000

Why is this important?

Edited: Changing type tags can lead to cryptic errors

Fri, 03 Jul 2026 09:58:25 +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

Edited: Syntax-quoted lists can return nil, differs from ClojureScript

Sun, 28 Jun 2026 21:35:41 +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.

Closed: Why do literal vectors ignore type hinting?

Mon, 22 Jun 2026 18:05:43 +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?

Closed: Can't type hint literal collection containing runtime values

Mon, 22 Jun 2026 18:05:06 +0000

Currently type hints on literals containing runtime values are lost:

`
user=> (set! warn-on-reflection true)
true
user=> (fn [x] (java.util.HashMap. ^java.util.Map {"foo" x}))
Reflection warning, null:1:9 - call to java.util.HashMap ctor can't be resolved.

function[user/eval7479/fn--7480]

A workaround that currently works is to introduce a local and type hint the binding

`
user=> (fn [x] (let [^java.util.Map m {"foo" x}] (java.util.HashMap. m)))

function[user/eval7487/fn--7488]

The attached patch fixes this issue by tracking type hints for literal values, making the reflection go away even in the original case

`
user=> (set! warn-on-reflection true)
true
user=> (fn [x] (java.util.HashMap. ^java.util.Map {"foo" x}))

function[user/eval7479/fn--7480]

Approach: preserve user hints in literal collections
Patch: 0001-CLJ-1929-preserve-type-hints-in-literals.patch

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.

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

Fri, 12 Jun 2026 16:15:43 +0000

Yes, you need to bootstrap Clojure 1.9+ using an existing version of Clojure, if you're compiling it.

I have to admit, I still don't really understand why distros/package manager folks insist on trying to do this with things that are essentially just libraries on Maven Central? You risk creating builds of Clojure that are not the same as what the vast majority of people just download from Maven as project dependencies.

Closed: Implement reader literal and print support for PersistentQueue data structure

Tue, 09 Jun 2026 22:58:49 +0000

Clojure's PersistentQueue structure has been in the language for quite some time now and has found its way into a fair share of codebases. However, the creation of queues is a two step operation often of the form:

`
(conj clojure.lang.PersistentQueue/EMPTY :a :b :c)

;=> #
`

A better experience might be the following:

queue [:a :b :c]

;=> #queue [:a :b :c]

(pop #queue [:a :b :c])

;=> #queue [:b :c]
`

This syntax is proposed and discussed in the Clojure-dev group at https://groups.google.com/forum/?fromgroups#!topic/clojure-dev/GQqus5Wycno

Open question: Should the queue literal's arguments eval? The implications of this are illustrated below:

`
;; non-eval case

queue [1 2 (+ 1 2)]

;=> #queue [1 2 (+ 1 2)]

;; eval case

queue [1 2 (+ 1 2)]

;=> #queue [1 2 3]
`

The answer to this open question will determine the implementation.

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

Mon, 08 Jun 2026 15:35:28 +0000

Here are a few more libraries that are light wrappers over the jdk HttpClient. Notably they expose a way to send a response body handler with the request, as HttpClient does.

https://github.com/exoscale/telex
https://github.com/onionpancakes/hop

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.

Commented: `eval` using functions with metadata

Thu, 04 Jun 2026 02:35:24 +0000

#= is undocumented because it is not intended to be used outside the compiler.

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

Commented: Should reduce-kv support String?

Mon, 01 Jun 2026 00:49:45 +0000

i agree that it matching nth would be the most consistent.

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

Wed, 27 May 2026 10:02:45 +0000

Follow up discussion is happening on this thread on the Clojurians Slack: https://clojurians.slack.com/archives/C03S1KBA2/p1779097281433139

Closed: Consider allowing passing two arguments to sets used as functions

Tue, 26 May 2026 13:56:17 +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

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

Mon, 25 May 2026 12:20:42 +0000

If you know you're dealing with infinite sequences, that's the use case for lazy operations -- just don't use transducers on them.

Answer selected: Reflection warning when long hint on an argument

Fri, 08 May 2026 10:11:04 +0000

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

Comment edited: Do primitive type hints in fn arguments turns the return value as an Object?

Sat, 02 May 2026 11:07:04 +0000

Indeed @alexmiller, it seems the same issue as https://ask.clojure.org/index.php/15067/reflection-warning-when-long-hint-on-an-argument

Was there any reason why this didn't go forward? Is it more involved than a simple bugfix? Asking because I cannot see the ticket.

Closed: Unroll constantly to improve performance of multi-arity calls

Tue, 07 Apr 2026 21:25:53 +0000

This was found to be a hot spot when testing some Specter use cases.

Review of common uses of constantly shows that the arity 1 case is the most common use of `constantly` in the wild, so only unrolled to two arguments.

Perf test:

(use 'criterium.core)
(def f (constantly 1))
(bench (dotimes [_ 1000] (f)))
(bench (dotimes [_ 1000] (f 1)))
(bench (dotimes [_ 1000] (f 1 2)))

;; Results:
;; Arity Before         After
;; 0     611.455589 ns 607.800747 ns    (no change was expected)
;; 1     3.098828 µs    611.116510 ns    (~5x improvement)
;; 2     3.508726 µs    620.415032 ns    (~5x improvement)

*Patch:* 0001-CLJ-2228-Improve-performance-of-constantly.patch

*Prescreened by:* Alex Miller

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.

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

Sun, 05 Apr 2026 09:19:47 +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)

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

Closed: Controlled Bailout, Jira issue 2213

Tue, 31 Mar 2026 19:54:30 +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.

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

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

Thu, 26 Mar 2026 17:24:24 +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.

Edited: Evaluating forms using eval can create a valid undesirable recursion point

Thu, 26 Mar 2026 04:05:02 +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.

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

Sat, 28 Feb 2026 06:27:25 +0000

This is fair. I created https://clojure.atlassian.net/browse/CLJ-2944 to track this.

Answer selected: Is it legal for a namespace to start with a number?

Mon, 23 Feb 2026 19:13:52 +0000

As far as I can tell, there is no reason a namespace segment other than the first can't start with a number.

Comment edited: CVE-warning in org.fressian/fressian <- org.clojure/data.fressian

Fri, 20 Feb 2026 02:51:41 +0000

Package URI looks right.

For CPE, you'll have to put `unknown`. I used the CPE search on the NVD site and could not find any CPEs for `fressian`, nor does the 2018 CVE data feed contain `fressian`.

ODC Integration: CLI is the closest option.

ODC Version: https://github.com/clj-holmes/clj-watson/blob/main/deps.edn#L10 so it's current 12.1.6 unless you're overriding it locally.

Clojure Q&A - Recent activity in Clojure

Commented: Checked behavior in 1.13 destructuring outside of `:keys!` like directives

Commented: Bytecode not 100% deterministic given identical inputs?

Closed: Why gen-class does not generate default interface methods?

Commented: Approach to case tableswitch may consume significant bytecode space

Answered: Some core predicates aren't generic over all types

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

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

Edited: destructuring with :keys! and :or

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

Closed: When using remote prepl server, *repl* is false, preventing use of add-lib and related functions

Closed: Improve javadoc especially for tool usage

Commented: Support for automatic promotion to BigDecimal in +', *', etc.

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

Commented: Somewhat confusing sorted-set behavior

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

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

Answered: Will :keys! work with nested maps?

Closed: error printed using pprint in clojure 1.13.0-alpha1

Commented: Possibly avoidable identity call to force instance method on Class literals

Edited: Changing type tags can lead to cryptic errors

Edited: Syntax-quoted lists can return nil, differs from ClojureScript

Closed: Why do literal vectors ignore type hinting?

Closed: Can't type hint literal collection containing runtime values

function[user/eval7479/fn--7480]

function[user/eval7487/fn--7488]

function[user/eval7479/fn--7480]

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

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

Closed: Implement reader literal and print support for PersistentQueue data structure

queue [:a :b :c]

queue [1 2 (+ 1 2)]

queue [1 2 (+ 1 2)]

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

Answered: Object.clone() confusion

Commented: `eval` using functions with metadata

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

Answered: :or destructuring doesn't update object

Commented: Should reduce-kv support String?

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

Closed: Consider allowing passing two arguments to sets used as functions

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

Answer selected: Reflection warning when long hint on an argument

Comment edited: Do primitive type hints in fn arguments turns the return value as an Object?

Closed: Unroll constantly to improve performance of multi-arity calls

Answered: Optimize `eduction`

Answered: "Nested" vs "lateral" exception causes

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

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

Answered: Is taggedliteral's equality check inefficient?

Closed: Controlled Bailout, Jira issue 2213

Idea: Exceptions

Idea: Like for/doseq

Idea: Using if-let

Idea: Threading macros

Final Words

Answered: Optimized str function

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

Edited: Evaluating forms using eval can create a valid undesirable recursion point

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

Answer selected: Is it legal for a namespace to start with a number?

Comment edited: CVE-warning in org.fressian/fressian <- org.clojure/data.fressian

Closed: When using remote prepl server, repl is false, preventing use of add-lib and related functions

Idea: Using `if-let`