Clojure Q&A - Recent questions and answers in Clojure

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'
`

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

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

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

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

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.

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

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

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

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

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

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

Answered: Changing type tags can lead to cryptic errors

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

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

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

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

Possibly avoidable identity call to force instance method on Class literals

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

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

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

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

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

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

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

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

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

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

error printed using pprint in clojure 1.13.0-alpha1

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

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

reported by djblue in #clojure-dev

Syntax-quoted lists can return nil, differs from ClojureScript

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

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

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

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

Clojure 1.12.5
user=> `()
()

ClojureScript returns an empty list in these cases:

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

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

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

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

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

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

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

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

Answered: Why do literal vectors ignore type hinting?

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

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

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

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

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

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

Examples of prior art:

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

Answered: Object.clone() confusion

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

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

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

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

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

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

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

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

Answered: :or destructuring doesn't update object

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

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

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

Answered: `eval` using functions with metadata

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

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

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

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

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

Answered: Should reduce-kv support String?

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

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

Consider allowing passing two arguments to sets used as functions

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

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

It already works in CLJS:

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

In Clojure, it errors out:

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

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

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

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

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

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

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

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

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

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

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

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

Have you recently updated Clojure?

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

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

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

Answered: Reflection warning when long hint on an argument

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

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

Answered: Optimize `eduction`

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

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

Answered: "Nested" vs "lateral" exception causes

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

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

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

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

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

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

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

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

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

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

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

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

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

Answered: Is taggedliteral's equality check inefficient?

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

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

Answered: Optimized str function

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

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

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

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

Similar work has been done in spork and stringer

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.

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

Tue, 17 Mar 2026 15:46:56 +0000

I logged this as https://clojure.atlassian.net/browse/CLJ-2947 but I don't think it's a big deal.

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

Fri, 27 Feb 2026 15:11:56 +0000

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

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

Mon, 23 Feb 2026 19:12:09 +0000

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

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

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

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

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

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

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

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

Thank you!

Answered: Is it valid for metadata to have metadata?

Tue, 17 Feb 2026 15:10:58 +0000

Thanks for the additional info! I do think this is bug, which I've filed at https://clojure.atlassian.net/browse/CLJ-2941 and patch is welcome.

If you need to sign the contributor agreement or get access to jira, please follow process at https://clojure.org/dev/dev#_becoming_a_contributor

Answered: bit-count in cljs but not clj

Fri, 30 Jan 2026 14:20:06 +0000

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

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

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

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

definterface doesn't expose this.

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

Answered: How to force clojure.spec generator to skip a field

Thu, 15 Jan 2026 10:26:11 +0000

Given that you're using gen/let, why not just this?

(gen/let [x (s/gen (s/keys :opt [::a]))
          y (s/gen (s/keys :opt [::a]))]
  {:x x
   :y (cond-> y (not (contains? x ::a)) (dissoc ::a))})

Alternatively:

(gen/let [x (s/gen (s/keys :opt [::a]))
          y (s/gen (cond-> (s/keys :opt [::a])
                     (not (contains? x ::a))
                     (s/and #(not (contains? % ::a)))))]
  {:x x
   :y y})

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

Tue, 13 Jan 2026 22:47:58 +0000

Reviewing this it appears to be the same issue as cannot-create-anonymous-primitive-functions which tracks with this jira CLJ-919

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

Tue, 13 Jan 2026 19:06:31 +0000

Created jira and patch at https://clojure.atlassian.net/browse/CLJ-2936

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

Mon, 12 Jan 2026 22:26:24 +0000

Created feature request jira https://clojure.atlassian.net/browse/CLJ-2935

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

Mon, 12 Jan 2026 22:08:25 +0000

"Qualified" means more than one thing depending on context. Java classes are "qualified" by their package name. symbols are "qualified" by their namespace. class names are syntactically represented by a symbol which has overlapping senses - the class package is a dotted prefix that lives in the "name" part of the symbol.

qualified-symbol? is specifically referring to namespace qualification.

My guess is that Rich would say that the original sentence is correct and written as intended.

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

Fri, 09 Jan 2026 16:31:43 +0000

I agree that this is a false positive. Neither org.fressian/fressian nor org.clojure/data.fressian depend on either Datomic or h2, either explicitly or implicitly, even via test deps, so not sure how that could be possible even via test deps.

clj-watson depends on https://github.com/dependency-check/DependencyCheck to do its checks, and you can report false positives as an issue on its issue tracker https://github.com/dependency-check/DependencyCheck/issues.

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

Tue, 23 Dec 2025 08:15:40 +0000

Updating the version of rlwrap by building it from source fixed the issue.

The version installed on my FreeBSD system was 0.45, the latest version available for the package manager, building from source yielded version 0.48, which seems to have fixed the display bug :)

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

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

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

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

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

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

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

non-octal characters:

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

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

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

Answered: [clojure.edn] Leading zeros in numbers

Mon, 15 Dec 2025 20:05:17 +0000

Leading zeroes in Clojure should largely follow the lead of Java when the reference is unclear:

Long - multiple leading 0s allowed, treated as octal
BigInteger - multiple leading 0s allowed, treated as decimal in Java BigInteger, octal in Clojure (this is a difference, but supported by the reader reference page)
Double - multiple leading 0s allowed in either whole number part of exponent, treated as decimal
BigDecimal - multiple leading 0s allowed, treated as decimal

With respect to edn, there are additional constraints - octal is not supported, and leading 0s not allowed in integers, but are allowed in decimal whole and exponents by my reading. I do not see support for your assertion "even for floats" - the constraint is listed only for integers).

Thus I would expect that any leading 0s in an integer (with or without N suffix) should be invalid, yet they are all read as octal. So that seems like a potential bug. Because clojure.edn is a superset of edn, you could potentially contend this is additive syntax/semantics beyond edn but seems a little confusing.

For floating points, by my reading, leading 0s in whole or exponent parts are allowed, so no issue or difference from Clojure or Java there afaict.

Answered: `find` docstring enhancement proposal

Thu, 11 Dec 2025 20:35:32 +0000

See https://clojure.org/reference/data_structures#Maps (and other places on that page) where "entry" is referred to and, in particular:

"...a sequence of map entries, which are key/value pairs"

See also https://docs.oracle.com/en/java/javase/25/docs/api/java.base/java/util/Map.html where "entry" is referred to several times and also defined as a key/value pair.

Searching the web for map entry -java seems to indicate this is pretty common terminology in other languages as well.

Answered: Aliased namespace in tagged literal

Thu, 11 Dec 2025 20:18:34 +0000

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

I reworded the title and problem as this slips into solution space (and I'm not sure that solution is even possible given the reader nature of the problem).

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

Tue, 09 Dec 2025 22:55:20 +0000

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

Other old and related JIRAs for relevance: CLJ-1286 CLJ-1252

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

Tue, 09 Dec 2025 22:44:08 +0000

Probably only known to Rich, don't think these inconsistencies are important.

Answered: bug bigdec

Tue, 09 Dec 2025 22:36:21 +0000

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