Clojure Q&A - Recent questions and answers

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

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

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

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

Answered: Optimize `eduction`

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

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

Answered: "Nested" vs "lateral" exception causes

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Answered: Is taggedliteral's equality check inefficient?

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

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

Answered: Optimized str function

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

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

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

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

Similar work has been done in spork and stringer

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: Is the recent change to flow's futurize safe?

Wed, 18 Mar 2026 13:41:35 +0000

Created ASYNC-275.

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: shasum not found error when using ./posix-install on linux

Wed, 11 Mar 2026 22:05:18 +0000

We've added a version verification step in the installer. The posix and linux installers use different tools to calculate the sha of the downloaded file according to the expectations of these platforms. You should use the installer that is most appropriate - here, that seems to be the linux installer (for Amazon Linux).

Answered: tools.cli: capture unrecognized options as unparsed arguments

Fri, 06 Mar 2026 01:40:33 +0000

Logged as https://clojure.atlassian.net/browse/TCLI-107 with a proposed syntax:

:subcommand :explicit will have the same meaning as :in-order true does today
:subcommand :implicit will have the behavior the OP wants here, i.e., an unknown option is treated as if there were an implicit subcommand present

Deprecate :in-order true (in favor of :subcommand :explicit).

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: Could some calls to clojure.core/= be replaced by clojure.core/identical?

Wed, 25 Feb 2026 23:51:22 +0000

The 1.2.x versions of core.cache use delays inside the wrapped ns so the original aspect of this Q is moot, but we could probably still change all those = to identical? for :: style keywords in the library.

Answered: clojure.core.cache caches delays that hold exceptions as of version 1.2.254

Wed, 25 Feb 2026 23:07:51 +0000

Version 1.2.263 solves both the cache stampede bug and the cached exceptions bug, and does so without locking. Thank you, Claude Opus 4.6.

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: clojure.java.doc.api/javadoc-data-fn does not include constructor info

Fri, 13 Feb 2026 18:33:40 +0000

That functionality is now present in the v0.1.4 release.

Answered: javadoc-data-fn does not find selected method for inherited methods

Fri, 13 Feb 2026 18:33:01 +0000

Great feedback.

We were indeed not looking for inherited methods. That functionality is now present in the v0.1.4 release.

Answered: does deps.edd support "exclusion" with wild cards ?

Sun, 08 Feb 2026 17:14:18 +0000

There is an existing enhancement jira for this at https://clojure.atlassian.net/browse/TDEPS-141

TypedArrays don't implement ICounted in cljs

Thu, 05 Feb 2026 12:37:54 +0000

I just discovered that JS TypedArrays (Uint8Array et al) do not implement ICounted out of the box, even though it's trivial to make them do so. As a result count doesn't work on them; this is in contrast to Clojure where count works on arrays of primitives. Can/should this be added, or is the current behaviour intended?

(count (js/Uint8Array. [1 2 3]))
;; Execution error (Error) at (<cljs repl>:1).
;; No protocol method ICounted.-count defined for type object: 1,2,3
;=> :repl/exception!

(extend-protocol ICounted
 js/Uint8Array 
 (-count [this] (alength this)))
;=> #object [Function]

(count (js/Uint8Array. [1 2 3]))
;=> 3

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

Answered: Core Cache and Count

Thu, 29 Jan 2026 14:03:17 +0000

Seems reasonable.

Created https://clojure.atlassian.net/browse/CCACHE-67

I'm happy to help screen a patch if you're so inclined to provide one.

Answered: `flow/ping-proc` can be slow or fail to respond, even when process isn't busy

Wed, 28 Jan 2026 19:54:27 +0000

Thanks, we've been discussing ways to specify filters for proc state datafication.

Answered: TDEPS-269: checksums should use sha256sum instead of shasum

Tue, 27 Jan 2026 15:18:40 +0000

Thanks, I logged as https://clojure.atlassian.net/browse/TDEPS-275 and will change at least the Linux installer today, need to decide which to use for Posix installer.

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: Improving curl options for CLI install scripts (brew-install)

Mon, 26 Jan 2026 19:36:29 +0000

Logged as https://clojure.atlassian.net/browse/TDEPS-274

Answered: clojure.java.doc.api/javadoc-data-fn does not include return types for methods

Fri, 23 Jan 2026 21:55:59 +0000

I just released v0.1.3 that now includes the :return-type in the response from jdoc-data

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: false positive warning: "cljs.core/+, all arguments must be numbers"

Tue, 06 Jan 2026 20:07:06 +0000

The problem is the when. The inference mechanism isn't strong enough to narrow the return type (number|nil) if the type of the argument is known.

Answered: ClojureScript :preloads doesn't work with just cljs.main --repl

Fri, 26 Dec 2025 20:13:53 +0000

I just figured that the preloads do get compiled, it is just that the goog.requires aren't being added to the on-the-fly generated main.js.

Leaving a possible patch here in case there is interest :

diff --git a/src/main/clojure/cljs/cli.clj b/src/main/clojure/cljs/cli.clj
index da4f2761..9087151c 100644
--- a/src/main/clojure/cljs/cli.clj
+++ b/src/main/clojure/cljs/cli.clj
@@ -321,7 +321,8 @@ present"
         reopts (merge repl-env-options (select-keys opts [:main :output-dir]))
         _      (when (or ana/*verbose* (:verbose opts))
                  (util/debug-prn "REPL env options:" (pr-str reopts)))
-        renv   (apply (target->repl-env (:target options) repl-env) (mapcat identity reopts))]
+        renv   (-> (apply (target->repl-env (:target options) repl-env) (mapcat identity reopts))
+                   (assoc :compiler-opts opts))]
     (repl/repl* renv
       (assoc opts
         ::repl/fast-initial-prompt?
diff --git a/src/main/clojure/cljs/repl/browser.clj b/src/main/clojure/cljs/repl/browser.clj
index 2c907c6d..9b333127 100644
--- a/src/main/clojure/cljs/repl/browser.clj
+++ b/src/main/clojure/cljs/repl/browser.clj
@@ -182,7 +182,7 @@
 
 (defn send-static
   [{path :path :as request} conn
-   {:keys [static-dir output-dir host port gzip?] :or {output-dir "out"} :as opts}]
+   {:keys [static-dir output-dir host port gzip? compiler-opts] :or {output-dir "out"} :as opts}]
   (let [output-dir (when-not (.isAbsolute (io/file output-dir)) output-dir)]
     (if (and static-dir (not= "/favicon.ico" path))
       (let [path (if (= "/" path) "/index.html" path)
@@ -224,7 +224,11 @@
                                       clojure.browser.repl/PORT ~port}
                                   (merge (:closure-defines @browser-state))
                                   cljsc/normalize-closure-defines
-                                  json/write-str)]
+                                  json/write-str)
+                preloads (when-let [preloads (:preloads compiler-opts)]
+                           (mapv (fn [ns-symb]
+                                   (str "document.write('<script>goog.require(\"" (munge ns-symb) "\");</script>');"))
+                                 preloads))]
             (server/send-and-close conn 200
               (str "var CLOSURE_UNCOMPILED_DEFINES = " closure-defines ";\n"
                    "var CLOSURE_NO_DEPS = true;\n"
@@ -233,6 +237,7 @@
                    (when (.exists (io/file output-dir "cljs_deps.js"))
                      (str "document.write('<script src=\"" output-dir "/cljs_deps.js\"></script>');\n"))
                    "document.write('<script src=\"" output-dir "/brepl_deps.js\"></script>');\n"
+                   (when preloads (str/join "\n" preloads))
                    "document.write('<script>goog.require(\"clojure.browser.repl.preload\");</script>');\n")
               "text/javascript" "UTF-8"))

It is basically adding the compiler options to the repl environment, so they are available when generating main.js, then adding one goog.require per preload.

Answered: How to access non-jar artifacts (aar, zip) downloaded via tools.deps in build.clj?

Wed, 24 Dec 2025 18:03:56 +0000

In tools.build you can find these paths in the :libs key of the basis when you build it, so that would give you the path.

You can then use unzip in the tools.build api to help unzipping it. See https://clojure.github.io/tools.build/clojure.tools.build.api.html#var-unzip

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

Answered: `(max "x" "y")` used to return "y", now it returns "x"

Mon, 22 Dec 2025 16:57:28 +0000

The docstring of max implies that it should be used for numbers.

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: `derive [tag] [parent]` accepts non namespaced keyword/symbol as `tag` ?

Mon, 15 Dec 2025 20:54:55 +0000

Reading between the lines of this commit message, it seems like the intent was to relax the requirements on namespacing for private hierarchies (so, required for global but not for private).

Thus, I'm going to treat this as documentation issue in Clojure (presumably adding this constraint would break some existing code). Logged as https://clojure.atlassian.net/browse/CLJ-2934.

Not sure on CLJS.

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: Trying to extract vec from vec - conj not working?

Mon, 15 Dec 2025 04:02:15 +0000

Thanks Harold. I see.

For others coming here Harolds comment above is the answer (I don't know how to select it as the answer directly).

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

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

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

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

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