Clojure Q&A - Search results for 2026年2月中能电气002544建仓时机

Spec 2: Closed Generators

Mon, 12 Sep 2022 08:36:26 +0000

Hello,

is it possible to get a "closed" generator from a `s/select` form
and/or make it the default in Spec 2?

From the example in the Wiki:

(ns user
  (:require [clojure.alpha.spec :as s]))

(s/def ::id int?)
(s/def ::first string?)
(s/def ::last string?)
(s/def ::user (s/schema [::id ::first ::last ::addr]))

(s/def ::my-user (s/select ::user [::id]))

(s/exercise ::my-user)

This generates users that have more keys than what I selected:

([#:user{:id 0} #:user{:id 0}]
 [#:user{:addr #:user{:city "1"}, :first "O", :id 0}
  #:user{:addr #:user{:city "1"}, :first "O", :id 0}])

I believe it is the same data which the `s/schema` for the `::user`
spec generates. My guess is this just hasn't been implemented yet.

Would it be possible to support this?

Clojure Spec 2. Unexpected s/with-gen behaviour

Fri, 09 Sep 2022 10:49:50 +0000

When using regular expression operators (s/alt s/cat etc ) to describe sequences, s/with-gen doesn't work as I would have expected. It completely ignores the generator passed to the definition. Eg:

(require '[clojure.alpha.spec :as s])
(require '[clojure.alpha.spec.gen :as gen])
(s/def ::some-spec 
 (s/with-gen string? (constantly (gen/return "olar"))))

(gen/sample (s/gen ::some-spec))
 ;;=> ("olar" "olar" "olar" "olar" "olar" "olar" "olar" "olar" "olar" "olar")

The above generator works as I would expected, now if we try to create a similar one for s/alt we get unexpected results:

(s/def ::some-other-spec 
 (s/with-gen
  (s/alt :greetings #{:olar :oizito :oi :hello :hey :yo :hallo}
             :farewell #{:bye :bye-bye :hasta-la-vista :tchussy :tchau-kakao})
  (constantly (gen/return [:tchau-kakao]))))

(gen/sample (s/gen ::some-other-spec))
;;=> => ([:olar] [:hasta-la-vista] [:hallo] [:hallo] [:tchussy] [:oi] [:bye-bye] [:tchussy] [:tchau-kakao] [:yo])

Is this a bug or is it expected somehow?

In Spec 2, is this a bug?

Wed, 11 Mar 2020 10:06:44 +0000

Just reporting an error I've come across while using Spec 2 of SHA "b29ae46".

(s/def ::special-name   
  (s/and string? #(clojure.string/starts-with? % "Special")))
(s/def ::schema-1    (s/schema [::special-name]))
(s/valid? ::schema-1 {::special-name "Special Person"})
;;=> true

(s/def ::name        ::special-name)
(s/def ::schema-2    (s/schema [::name]))
(s/valid? ::schema-2 {::name "Special Person"})
Execution error (IllegalArgumentException) at clojure.alpha.spec.protocols/eval5664$fn$G (protocols.clj:11).
No implementation of method: :conform* of protocol: #'clojure.alpha.spec.protocols/Spec found for class: clojure.lang.Keyword

In Spec 2, are nested schemas illegal?

Wed, 11 Mar 2020 09:27:15 +0000

One of the problems that I've run into while using Spec 2.

(s/def ::number      number?)
(s/def ::boolean     boolean?)
(s/def ::schema      (s/schema [::number ::boolean]))
(s/def ::only-number (s/select ::schema [::number]))
(s/def ::this-works  (s/keys :req [::only-number]))
(s/def ::this-fails  (s/schema [::only-number]))
Execution error (AssertionError) at clojure.alpha.spec.impl/schema-impl (impl.clj:422).
Assert failed: (every? (fn* [p1__6948#] (if-let [sp (s/get-spec p1__6948#)] (not (select? sp)) true)) ks)

I made up this example to replicate an error I've got while I was creating a wrapper for AWS DynamoDB REST API.

clojure spec vs plumatic schema

Wed, 17 Apr 2024 04:11:04 +0000

A colleague brought to my attention that Clojure Spec is still alpha and that Plumatic Schema might be a better way to do the same tipe of spec.

Do you folks have any advice?

Cheers!

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

Mon, 23 Feb 2026 19:43:34 +0000

As of version 1.2.254 of org.clojure/core.cache, using a value-fn that throws will cause an entry to be added to the cache associated with a Delay with :status :failed and the exception as a value.

The code below can be used to compare the behavior between versions 1.1.234 and 1.2.254.

(require '[clojure.core.cache.wrapped :as cw])

(def counter (atom 0))

(defn value-fn [v]
  (prn :value-fn-called)
  (swap! counter inc)
  (if (= @counter 1)
    (throw (ex-info "thrown" {}))
    v))

(def test-cache (cw/lu-cache-factory {} :threshold 10))

(reset! counter 0)
; this will throw
(cw/lookup-or-miss test-cache "throw" value-fn)
; in 1.1.234 this will call value-fn again and not throw; in 1.2.254, it won't call and return
; the cached delay result, which is an exception
(cw/lookup-or-miss test-cache "throw" value-fn)

; evict to force call to value-fn
(cw/evict test-cache "throw")

This is related to work done in CCACHE-65 to avoid cache stampede in multi-threaded applications, and could be related to what has been reported in CMEMOIZE-31.

This was initially reported in Clojurians Slack.

What is the canonical way to share bundles of predicates + generators in clojure spec?

Wed, 17 Nov 2021 11:51:41 +0000

I've been trying out Clojure spec and I often face situations in which I have to come up with a custom predicate function. Then sometimes these predicate functions require a custom generator. How can I share this predicate+generator bundle between different attributes?

(Also not so important but, can I call this bundle of predicate-fn + generator a spec?)

Example:
Suppose I have the custom predicate:

   (defn local-date? [x]
      (instance? LocalDate x))

and then I define a brand new generator function for it:

(defn local-date-generator []
  (gen/fmap #(LocalDate/ofInstant (Instant/ofEpochMilli %) (ZoneId/of "UTC")) 
                       (gen/large-integer)))

I can go on and define an attribute like:

(s/def :person/birth-date (s/with-gen local-date local-date-generator))

but then I would have to define this s/with-gen every time I create a LocalDate attribute.

How can I abstract that away?

I've come to the conclusion that the right way to do that would be to define an attribute in a namespace (e.g myprojec.specs) in which I create an attribute with that spec

(s/def ::local-date (s/with-gen local-date local-date-generator))

and then just re-use it elsewhere

(s/def :person/birth-date :myproject.specs/localdate)

What are the alternatives?

Problem with select in schema with namespaced keys of schema with unnamespaced keys

Fri, 24 Jul 2020 18:43:51 +0000

In specs alpha 2, if we define a clojure.alpha.spec/select of a spec defined as a s/schema of a nested spec that is itself a s/schema, but of unnamespaced keys, and try to use it with either s/valid? or s/exercise, we get exceptions:
s/valid throws *"No implementation of method: :conform of protocol: #'clojure.alpha.spec.protocols/Spec found for class: clojure.lang.Keyword" and s/exercise throws "Unable to resolve spec: :foo"** (where :foo is the unnamespaced key).

An example can illustrate the issue better:

; Context
(s/def ::foo int?)
(s/def ::inner (s/schema [{:foo ::foo}]))
(s/def ::outer (s/schema [::inner]))

; Works as expected:
(s/exercise ::outer)
(s/exercise (s/select ::inner [*]))
(s/valid? (s/select ::inner [*]) {:foo 10})

; Fails with "Unable to resolve spec: :foo"
(s/exercise (s/select ::outer [*]))

; Fails with "No implementation of method: :conform* of protocol: #'clojure.alpha.spec.protocols/Spec found for class: clojure.lang.Keyword"
(s/valid? (s/select ::outer [*]) {::inner {:foo 10}})

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

Mon, 12 Jan 2026 20:02:41 +0000

Context
For historical reasons the JVM type system's support for Unicode code points is poor, and while this is usually invisible to the developer it becomes a hassle when String literals containing non-Latin1 code points are used in code. It also becomes particularly problematic when cross-platform (cljc) code is attempting to do this, since other platforms may not share this historical oddity so solutions that "work" in ClojureJVM may break in other dialects.

For example, the transgender flag emoji (a single grapheme cluster that happens to be defined by 5 Unicode code points) cannot easily be constructed at the REPL or in a source file without detailed knowledge of the JVM's history (and associated knowledge of UTF-16, an increasingly obsolete character encoding).

Using the documented code points for this grapheme cluster with the JVM's Unicode escaping mechanism does not give the expected outcome:

The correct, but unintuitive solution is to remember that the JVM does not directly support Unicode code points in the supplemental planes, and then to translate the supplemental code point U+1F3F3 into its UTF-16 code unit / surrogate pair representation:

Note: I had to use screenshots for this, since ask.clojure doesn't appear to support Unicode supplemental code points properly either...

Question/request/proposal
Clojure can sidestep this issue in a purely accretive manner, providing better consistency across the JVM and other runtimes, by adding direct support for Unicode literals.

This would involve adding a new literal syntax that represents a single Unicode code point, and perhaps also a new literal syntax that represents a sequence of Unicode code points (perhaps supporting not only the novel Unicode code point literal, but also the existing Character and String literals). Both of these new literals would produce a standard JVM (or JavaScript, or ...) String object, in whatever native encoding those objects employ on their respective platforms - after such literals are read, it's all just the extant String data type - there is no runtime impact.

An example literal syntax

While I am not proposing a specific syntax for these new literals here (though such a task is a necessary step), for illustrative purposes here is an example of what these literals might approximately look like:

Single Unicode code point literals:

#U+0061: produces a String containing the Latin letter a: "a"
#U+1F921: produces a String containing the clown emoji (which ask.clojure cannot display)

Sequences of Unicode code point literals:

#U+[U+0061 U+0020 U+1F921]: produces the 3 grapheme cluster String: "a <clown emoji>"
#U+["a " U+1F921]: produces the same String, but demonstrates why it may be useful to support a mix of literals within the sequence (for readability)
#U+[\a \space U+1F921]: ditto
#U+[U+1F3F3 U+FE0F U+200D U+26A7 U+FE0F]: produces a String containing a single grapheme cluster (the transgender flag emoji)

This final example is an ideal test case, since the transgender flag emoji is a single Unicode grapheme cluster, defined by 5 Unicode code points, but on the JVM (for the historical reason listed originally) is made up of 6 Characters.

Note that the sequence literal may not be necessary, since str could be used with the single code point literal syntax; e.g. (str #U+1F3F3 #U+FE0F #U+200D #U+26A7 #U+FE0F). Whether shifting the cost of string concatenation from read-time to runtime matters or not is another topic worthy of deeper consideration.

Other notes
Orthogonal to this proposal (at least from a Clojure core perspective; from a user perspective they're closely related), it would also be useful if Clojure core (perhaps in the clojure.string namespace) had functions to turn Strings into sequences of code points (as integers) and vice versa. Both the JVM and JavaScript provide native APIs for doing this (and presumably other platforms do too), but providing these as standard functions in Clojure core (similar to what was done with parse-long, parse-double, and parse-boolean in Clojure v1.11) has value and is also purely accretive.

Accidental breaking change in data.json 2.5.0: previously, read succeeded, now it isn't

Wed, 25 Sep 2024 15:46:20 +0000

Here is a snippet of code that fails on data.json 2.5.0:

clj -Sdeps '{:deps {org.clojure/data.json {:mvn/version "2.5.0"}}}' -M -e '((requiring-resolve (quote clojure.data.json/read)) (clojure.lang.LineNumberingPushbackReader. (java.io.StringReader. "[\n  {\n    \"name\": \"position\",\n    \"type\": \"float32\",\n    \"count\": 3,\n    \"data\": [0,0,0]\n  },\n  {\n    \"name\": \"normal\",\n    \"type\": \"float32\",\n    \"count\": 3,\n    \"data\": [0,0,0]\n  },\n  {\n    \"name\": \"texcoord0\",\n    \"type\": \"float32\",\n    \"count\": 2,\n    \"data\": [0,0]\n  }\n]")))'

Execution error (IOException) at java.io.PushbackReader/unread (PushbackReader.java:166).
Pushback buffer overflow

The same code succeeds on 2.4.0:

clj -Sdeps '{:deps {org.clojure/data.json {:mvn/version "2.4.0"}}}' -M -e '((requiring-resolve (quote clojure.data.json/read)) (clojure.lang.LineNumberingPushbackReader. (java.io.StringReader. "[\n  {\n    \"name\": \"position\",\n    \"type\": \"float32\",\n    \"count\": 3,\n    \"data\": [0,0,0]\n  },\n  {\n    \"name\": \"normal\",\n    \"type\": \"float32\",\n    \"count\": 3,\n    \"data\": [0,0,0]\n  },\n  {\n    \"name\": \"texcoord0\",\n    \"type\": \"float32\",\n    \"count\": 2,\n    \"data\": [0,0]\n  }\n]")))'
[{"name" "position", "type" "float32", "count" 3, "data" [0 0 0]} {"name" "normal", "type" "float32", "count" 3, "data" [0 0 0]} {"name" "texcoord0", "type" "float32", "count" 2, "data" [0 0]}]

The gist of the problem: previously, Clojure's line numbering pushback reader could be used as an input to read. Now it can't: it throws an exception.

For reference, this is a json repro (a valid json!):

[
  {
    "name": "position",
    "type": "float32",
    "count": 3,
    "data": [0,0,0]
  },
  {
    "name": "normal",
    "type": "float32",
    "count": 3,
    "data": [0,0,0]
  },
  {
    "name": "texcoord0",
    "type": "float32",
    "count": 2,
    "data": [0,0]
  }
]

And, the formatted code: that uses the json:

(clojure.data.json/read 
  (clojure.lang.LineNumberingPushbackReader.
    (java.io.StringReader. "...")))

It seems the problem is introduced in https://clojure.atlassian.net/browse/DJSON-50

Spec2: Use case for multi-spec as Schema provider

Tue, 15 Jun 2021 21:18:25 +0000

I have a scenario where I'd like to define some attributes that are internal and common, and some other attributes that are external and dynamic, both related to the same "things". Specifically, I am trying to model a trading library. There are many different exchanges/brokers/services, but all of them talk about similar/equivalent things.
Let's take the example of an order, you can have some attributes that can be common in all services (they don't necessarily appear on all services):

(spec/def :order/id string?)
(spec/def :order/quantity number?)
(spec/def :order/side #{:buy :sell})

Then, every external service can have specific attributes related to how that service handles orders:

(spec/def :service1-order/execution-instructions (spec/coll-of string?))
(spec/def :service2-order/iceberg-quantity (spec/coll-of string?))

I was thinking on having a multi-spec returning schemas, so each service can define what schema to use for an order, on a key like :service/name, but all of them can be "selected" from :order/order.

(defmulti order-schema :service/name)

(defmethod order-schema :service1
  [_]
  (spec/schema [:order/id :order/quantity :order/side :service1-order/execution-instructions]))

(defmethod order-schema :service2
  [_]
  (spec/schema [:order/id :order/quantity :order/side :service2-order/iceberg-quantity]))

(defmethod order-schema :default
  [_]
  (spec/schema [:order/id :order/quantity :order/side]))

(spec/def :order/order (spec/multi-spec order-schema :service/name))

This can be useful also when nesting objects. Imagine I have an account that will contain orders. The account can also be specced as a multi-spec for each service:

(spec/def :account/id string?)
(spec/def :account/orders (spec/coll-of :order/order))

(spec/def :service1-account/type #{:spot :margin :futures})

(defmulti account-schema :service/id)

(defmethod account-schema :service1
  [_]
  (spec/schema [:account/id :account/orders :service1-account/type]))

(defmethod account-schema :default
  [_]
  (spec/schema [:account/id :account/orders]))

(spec/def :account/account (spec/multi-spec account-schema :service/id))

This would allow to select in the following manner:

(spec/def ::service1-account-info (spec/select :account/account [:service1-account/type :account/orders {:account/orders [:order/id :order/quantity :service1-order/execution-instructions]}]))

This way, external services can specify the information they handle about the common layer domain attributes and entities, as well as specify their specific attributes. The user is able to reuse a set of common functions that operate on the common attributes, and if different services provide these common attributes, they can be used interchangeably, while keeping a way to create functions and selections that are specific to specific services.

Does this use case make sense? Is there a different way to model this that would be better?

Thanks

Problems with s/union

Mon, 15 Mar 2021 09:49:01 +0000

While playing around with spec2, I'm seeing the following behavior which seems like a bug:

(s/def ::s1 (s/schema {:a string?}))
=> :dev.fp.livingdocs.specs/s1
(s/def ::s2 (s/schema {:b string?}))
=> :dev.fp.livingdocs.specs/s2
(s/def ::s3 (s/schema {:c string?}))
=> :dev.fp.livingdocs.specs/s3

;; The following is unexpected (neseted unions)
(s/def ::u (s/union ::s1 (s/union ::s2 ::s3)))
Execution error (IllegalArgumentException) at clojure.alpha.spec.protocols/eval1665$fn$G     (protocols.clj:20).
No implementation of method: :keyspecs* of protocol: #'clojure.alpha.spec.protocols/Schema found for class: clojure.lang.PersistentList
(s/def ::u (s/union (s/union ::s1 ::s2) ::s3))
Execution error (IllegalArgumentException) at clojure.alpha.spec.protocols/eval1665$fn$G (protocols.clj:20).
No implementation of method: :keyspecs* of protocol: #'clojure.alpha.spec.protocols/Schema found for class: clojure.lang.PersistentList

;; if I try to pull out the nested union into a separate keyword, it starts working 
(s/def ::u' (s/union ::s1 ::s2))
=> :dev.fp.livingdocs.specs/u'
(s/def ::u (s/union ::u' ::s3))
=> :dev.fp.livingdocs.specs/u
(s/explain (s/select ::u [:a :c]) {:a "bdfd"})
{:a "bdfd"} - failed: (fn [m] (contains? m :c))

;; but also this
(s/form ::ld/typed)
=>
(clojure.alpha.spec/schema
 [{:name clojure.core/string?, :type clojure.core/string?}])
(s/form ::ldd/editable)
=>
(clojure.alpha.spec/schema
 [{:optional clojure.core/boolean?,
   :maxLength clojure.core/integer?,
   :plainText clojure.core/boolean?,
   :excluexcludeFromTextCount clojure.core/boolean?}])
 
(s/def ::service
  (s/or :single (s/select (s/union ::ld/typed ::ldd/editable) [:type :name :optional])
         :multiple (s/select (s/union :ld/typed ::ldd/editable) [:type :name :maxLength])))
Execution error (IllegalArgumentException) at clojure.alpha.spec.protocols/eval1665$fn$G (protocols.clj:20).
No implementation of method: :keyspecs* of protocol: #'clojure.alpha.spec.protocols/Schema found for class: clojure.lang.PersistentList

In both cases s/union shows up in a nested position inside a form passed to a spec macro.

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

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

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

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

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

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

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

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

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

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

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

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

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

I think there's a typo in spec2 that breaks if you don't alias clojure.alpha.spec -> s

Mon, 16 Nov 2020 06:12:55 +0000

In a project, I required + aliased clojure.alpha.spec like this:

(ns example.core
    (:require [clojure.alpha.spec :as spec]))

Then I tried to define a simple spec like

(spec/def ::example-spec #(not (neg? %)))

Compiling gave the error that namespace s was undefined.

I believe this came down to a typo in clojure.alpha.spec/def. In file spec-alpha2/src/main/clojure/clojure/alpha/spec.clj, line 456, there is a backquoted s/spec but the alias at the top of the file is to sa. Here's line 456:

    (#{'fn 'fn* `c/fn} op) `(s/spec ~explicated-form)

After changing the line to

(#{'fn 'fn* `c/fn} op) `(sa/spec ~explicated-form)

my spec/def works successfully.

Does tools.deps treat a version (e.g. 1.2.3) as a range (i.e. [1.2.3,))?

Wed, 05 Jun 2024 16:53:59 +0000

Does tools.deps treat a version (e.g. 1.2.3) as a range (i.e. [1.2.3,)) like Maven and Gradle or like a fixed version (i.e. [1.2.3])? In addition, Maven has the concept of "soft" versions where the specified version is "preferred". Does tools.deps have a similar concept?

Problem with (s/nest) and (s/describe) in spec-alpha2

Tue, 20 Oct 2020 16:55:08 +0000

It looks like calling (s/describe) for (s/nest) specs fails with an exception.

The following call:

(s/describe (s/nest int?))

fails with this exception:

IllegalStateException Attempting to call unbound fn: #'clojure.core/unquote
    clojure.lang.Var$Unbound.throwArity (Var.java:45)
    clojure.alpha.spec.impl/nest-impl/reify--1676 (impl.clj:647)
    clojure.alpha.spec/form (spec.clj:258)
    clojure.alpha.spec/form (spec.clj:254)
    clojure.alpha.spec/describe (spec.clj:282)
    clojure.alpha.spec/describe (spec.clj:279)
    stem.i.log/eval16342 (log.clj:91)
    stem.i.log/eval16342 (log.clj:91)
    clojure.lang.Compiler.eval (Compiler.java:7177)
    clojure.lang.Compiler.eval (Compiler.java:7132)
    clojure.core/eval (core.clj:3214)
    clojure.core.server/prepl/fn--8941 (server.clj:232)

in spec-alpha2 with the latest commit from master

{:git/url "https://github.com/clojure/spec-alpha2.git" :sha "d514b06b25c41a676b95afcc9bfac8ca34c5741e"}

seque forces n+2 items ahead of consumer instead of n

Tue, 08 Oct 2024 21:33:17 +0000

seque's documentation says:

The queued seq will produce a concrete seq in the background, and can
get up to n items ahead of the consumer.

It seems to force n+2 items ahead of the consumer.

(let [producer (fn step [i]
                 (lazy-seq
                   (prn "producer" i)
                   (cons i (step (inc i)))))
      s (seque 1 (producer 0))]
  (Thread/sleep 1000)
  nil)
;="producer" 0
;="producer" 1
;="producer" 2
nil

`merge-with` doesn´t treat pair (vectors of 2) the same way `merge` does

Thu, 01 May 2025 11:25:20 +0000

;; merge
(merge {:a :b} [:a :c]) ;=> {:a :c}

;; merge-with
(merge-with (fn [_ x] x) {} {:a :b} [:a :c])
;; => class clojure.lang.Keyword cannot be cast to class java.util.Map$Entry

I think this happens because merge-with eventually calls seq on the "Map", expecting to get a "Map Entry" from which then it can extracts key and value, and fails when receiving a Vector, because seq will just yield one element at a time:

(key (first (seq {:a :c}))) ;; => :a
(key (first (seq [:a :c])))
;; => class clojure.lang.Keyword cannot be cast to class java.util.Map$Entry

I think it is justified to expect that (partial merge-with (fn [_ x] x)) should behave exactly as merge and my proposal is to make it happen, if what I described makes sense.

Thank you!

Provide slf4j 2.0 factory for tools.logging?

Tue, 15 Nov 2022 17:07:46 +0000

Is there interest in adding a slf4j 2 factory to clojure tools.logging ?

slf4j 2 changed how it discovers implementations - now it uses java ServiceLoader (standard) facilities.

On the client side version 1.x of API is compatible with version 2.x of API.
Implementations however have changed - how the implementation is loaded.

https://www.slf4j.org/faq.html#changesInVersion200

I don't think the old way of loading is working to find new slf4j 2.0 implementations that use service loader .
https://github.com/clojure/tools.logging#selecting-a-logging-implementation (edited) .

I could provide a PR if this is of interest.

clojure-clr nrepl - .NET Standard 2.1. does not work with .NET 7

Mon, 22 May 2023 18:59:50 +0000

I've been encountering some issues when attempting to load libraries using clojure-clr in .NET 7 (core.async and clojure.tools.nrepl)

With the recent inclusion of NREPL, I was keen to explore its functionality. However, I'm met with an error when I try to require the namespace, stating:

"Could not locate clojure/tools/nrepl with extensions .cljr, .cljc, .cljr, .cljr.dll, .cljc.dll, or .clj.dll on load path."

It's interesting to note the distinction between the clojure-clr nrepl library and core.async, particularly in comparison to libraries like clojure.test.generative. The latter, for example, is compiled to .NET Standard 2.1 and functions correctly.

To aid in addressing this problem, I've created a repository which reproduces the nrepl bug. You can find it here: https://github.com/Dangercoder/clojure-clr-bug-report-1

I'm using dotnet tooling to manage dependencies.

Furthermore, I believe that resolving the issues with core.async is crucial since it would enable interoperability with https://learn.microsoft.com/en-us/dotnet/api/system.threading.tasks.task?view=net-7.0. This feature is prevalent throughout the .NET environment.

Your assistance and input are much appreciated!

Why does `(str (map identity [1 2]))` return `clojure.lang.LazySeq@`? Is this a bug?

Wed, 12 Oct 2022 19:21:59 +0000

Why does (str (map identity [1 2])) return clojure.lang.LazySeq@3e2?
Is this a bug?
For example, (str (seq (map identity [1 2]))) returns (1 2) while (str (doall (map identity [1 2]))) still returns clojure.lang.LazySeq@3e2.

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

Mon, 22 Dec 2025 15:01:06 +0000

Hello,

I'm having a small bug with the Clojure REPL - when I enter a command, after pressing the enter key, the command gets displayed incorrectly - basically the beginning of the text of the command that I entered is displayed for the first few characters, and then everything after that is overwritten with the same text of the command displayed with an indentation.

Not sure if that's very clear, so I've added a pair of screenshots, "before and after", to illustrate.

This issue seems similar to this older question, although in that case the issue was with the rlwrap library, which was patched afterwards.

Is there a way to fix this?

passing command line arguments to clojure via `cider-jack-in` (GNUEmacs 27.1, CIDER 1.2.0)

Wed, 12 Oct 2022 02:16:48 +0000

I want to do cider-jack-in but I want to run with some predefined arguments passed to the clojure executable.

Each time I do a cider-jack-in, I want to pick up my :aliases {:dev {:extra-deps ... :extra-paths ... }} as defined in my deps.edn

Current workaround is to open an xterminal and type,
clj -A:dev
Then from GNUEmacs do cider-connect

Since clj is just wrapping rlwrap around /usr/bin/clojure, i understand I can run clojure via CIDER, but what's the best way to get the argument, -A:dev, passed in, too.

I tried setq'ing various things to the GNUEmacs variable, cider-clojure-cli-aliases without success.

Versions I am using...

CIDER 1.2.0 (Nice)

GNU Emacs 27.1 (build 1, x86_64-pc-linux-gnu, GTK+ Version 3.24.24, cairo version 1.16.0)
of 2021-03-27, modified by Debian

Trying to extract vec from vec - conj not working?

Mon, 15 Dec 2025 01:53:12 +0000

I'm trying to define a function that will extract a shorter vector from a longer vector. Here is the code:

(defn vfromv [v1 v2 start stop] 
    (loop [i start] 
      (if (> i stop)
        "Stop-val exceeded"
          (do
            (conj v2 (get v1 i))
            (println i)
            (println (get v1 i))
            (if (> i 0) (println (get v2 i)))
            (println v2)
            (recur (inc i))))))

Calling the function:
(vfromv [0 1 2 3 4 5 6 7 8 9] [] 2 6)

gives the repl output:
2
2
nil
[]
3
3
nil
[]
4
4
nil
[]
5
5
nil
[]
6
6
nil
[]
"Stop-val exceeded"

It looks like the conj function isn't working but I can't see why.

Can anyone help me understand why this isn't working?

Thanks.

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

Fri, 05 Dec 2025 09:56:54 +0000

Following links and snippets are about clojure.edn but because this logic is the same in clojure it also affects clojure reader as well.

Here is how symbol pattern is defined:

[:]?([\D&&[^/]].*/)?(/|[\D&&[^/]][^/]*)

It is eagerly matching prefix until the last slash character, after that it matches symbol name.

Then there is a wrong analysis of matched groups happen: ns is incorrectly set to everything until the last slash with validation that it is not ends with :/

Then in Symbol.intern call there is an another lookup for the first slash to split symbol into namespace and name.

The result is that keywords like this: ":/-/-", end up with namespace set to empty string "".

Looks like the least intrusive way to fix it is to use the same logic to find namespace borders in both places:

during symbol reading, lookup the first / to set ns instead of using the first matching group
in symbol interning the logic is correct

Another option is to use different regular expression:

[:]?([\D&&[^/]][^/]*/)?(/|[\D&&[^/]].*[^/])

This matches symbol prefix til the first slash keeping restriction "name can't end with slash".

Is it valid for metadata to have metadata?

Thu, 12 Feb 2026 15:45:20 +0000

Hello,

I am implementing a pretty printer and while adding/testing support for *print-meta* I noticed that pr prints an object whose metadata has metadata in the following way:

user> (binding [*print-meta* true]
        (pr-str (with-meta 'foo (with-meta {:bar :baz} {:frob :zork}))))
"^^{:frob :zork} {:bar :baz} foo"

When reading such a form, only the "outermost" metadata is preserved:

user> (binding [*print-meta* true]
        (let [s (pr-str (with-meta 'foo (with-meta {:bar :baz} {:frob :zork})))
              o (clojure.edn/read-string s)]
          {:o o
           :meta (meta o)
           :metameta (meta (meta o))}))
{:o foo, :meta {:bar :baz}, :metameta nil}

The behaviour is the same for clojure.core/read-string and also the tools.reader readers.

Can anyone clarify for me if this is either:

simply GIGO
a bug in the printer
a bug in the readers
a state that should be somehow disallowed
something else?

Neither the metadata reference nor the reader reference explicitly allow or disallow such a thing, as far as I can tell. Should they?

N.B. this is not an issue in any kind of production context and I'm not aware of any library or program that constructs such a thing. It's simply something I tested to see if/how it would break the pretty printer I'm building.

EDIT:

I dug into this some more with Nicola. Here's a perhaps much clearer case that demonstrates the reader isn't propagating nested metadata:

user> (let [o ^^:foo {1 2} {3 4}]
        {:o o :meta (meta o) :metameta (meta (meta o))})
{:o {3 4}, :meta {1 2}, :metameta nil}

:metameta should be {:foo true}.

In this section of MetaReader.invoke we are iterating over the entries of the meta map and manually associng them into the existing meta of the object; any metadata on the meta map itself is not preserved. I have a patch that adds a failing test case and correctly propagates the the meta map's metadata. If this is worth a ticket then I'm more than happy to attach it to that or send it to you directly.

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

Inconsistent errors in ratio parsing with either `clojure.edn/read` or `clojure.core/read`

Sat, 22 Nov 2025 17:12:47 +0000

user=> (clojure.edn/read-string "777/2") ;; no surprises
777/2
user=> (clojure.edn/read-string "0777/2") ;; wait, 0777 supposed to be 511
777/2
user=> (clojure.edn/read-string "0x777/2") ;; hexadecimal suddenly throws
Execution error (NumberFormatException) at user/eval175 (REPL:1).
Invalid number: 0x777/2
user=> (clojure.edn/read-string "32r777/2") ;; radix throws as well
Execution error (NumberFormatException) at user/eval177 (REPL:1).
Invalid number: 32r777/2
user=> (clojure.edn/read-string "777N/2") ;; same for BigInt
Execution error (NumberFormatException) at user/eval181 (REPL:1).
Invalid number: 777N/2

Inconsistent part here is octal integer numerator form. I would expect it to fail the same way as the rest of this list but not to silently drop leading zero and turn to not octal form at all.

Second part of the question is: Why other forms throws at all?

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

Mon, 10 Nov 2025 04:15:47 +0000

Is there support for BigDecimal promotion in the +', *', etc. clojure.core functions?

When I run the following code in the REPL:

(* 2 Double/MAX_VALUE)     ;; ##Inf, Doesn't auto-promote as was expected.
(*' 2 Double/MAX_VALUE)    ;; ##Inf, Expected that it would auto promote.

Following cases also didn't work:

(*' Double/MAX_VALUE 2)        ;; ##Inf, Moving around the arguments.
(*' 2.0 Double/MAX_VALUE)      ;; ##Inf, Using a Double literal instead.
(*' Double/MAX_VALUE 2.0)      ;; ##Inf
(*' Double/MAX_VALUE 2.0M)     ;; ##Inf, Using a BigDecimal literal instead.
(*' 2.0M Double/MAX_VALUE)     ;; ##Inf

I decided to check the Clojure compiler source for promotion, and based on my limited understanding of the code I see that DoubleOps is using the implementation of addP of OpsP abstract class (which just calls the normal add function) while there is one present for LongOps which can be found here.

Is this a bug? And if yes, I would like to work on the fix and I'll check the Development page of Clojure to do the needfull.

An undocumented breaking change in data.json

Thu, 23 Oct 2025 17:18:23 +0000

between the versions 1.1.0 and 2.0.0, data.json introduced a breaking change: The JSONWriter#-write signature changed from [object out] to [object out options]
On this commit:
https://github.com/clojure/data.json/commit/8f070ba94dc7c469f303259ce5f5bfa0b53d50bd
In release notes Release 2.0.0 on 2021-Mar-19 , there is no mention to JSONWriter or -write protocol changes.

I know it's a very old problem, but I think this documentation could be present.

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

Tue, 13 Jan 2026 18:10:48 +0000

This is related to this ancient ask, but it would be ideal if clojure.core/subs was type hinted with ^CharSequence rather than ^String, and used the subSequence() method instead of substring() (since the latter doesn't exist in CharSequence).

The single parameter version of subs would need to call s.length() as the second argument in the call to subSequence() (there is no single-arg version of that method, unlike substring()).

More generally, there are substantial benefits in using CharSequence instead of String throughout Clojure core, not only in the context of Java interop, but also when using custom String-like data structures (e.g. ropes).

[edit] @alexmiller mentioned this in another forum (and I'm capturing it here for posterity), but this might also require that the result be stred, to ensure the return type remains unchanged (subSequence() returns a CharSequence, unlike substring, which might break callers). There may be performance implications of adding that call for types other than String (but existing callers should be unaffected, since String.toString() is identity).

Evaluating forms using eval can create a valid undesirable recursion point

Mon, 16 Mar 2026 23:17:54 +0000

When the eval function in Clojure is called with an argument that is an instance of IPersistentCollection which likely isn't a special def-like form (the first element isn't a symbol at all or it does not start with "def"), the form is first wrapped in an anonymous function which then gets compiled and invoked, which indirectly evaluates the original form.

There aren't any extra checks performed and it makes forms like these 2 valid, which should normally be rejected and a compiler exception should be thrown:

(recur)

(let []
  (print "Hello")
  (Thread/sleep 1000)
  (recur))

where the 2nd form keeps printing "Hello" and loops infinitely over the outer wrapper function.

Create a vector with a non-`get` IFn

Thu, 02 Jan 2025 07:25:05 +0000

Goal: Create a new flavor of vector that is identical to the built-in vector, except when invoked, uses a different function (a variadic function defined by me, but concat is a good stand-in for demonstration purposes) instead of get.

Invoking a built-in vector implies get.

(def A (vector :a :b :c))
(get A 1) ;; => :b
(A 1) ;; => :b

No matter what we create to accomplish this task, the standard vector should behave exactly as before.

The new flavor of vector would behave ever-so-slightly differently. First, some example definitions using a new function, foo-vector.

(def B (foo-vector :a :b :c)) ;; => [:a :b :c]
(def C (foo-vector 'foo 'bar 'baz)) ;; => ['foo 'bar 'baz]
(def D (foo-vector 42 99)) ;; => [42 99]

All the usual functions work as before, because, for the most part, they are Clojure vectors.

(first B) ;; => :a
(get C 1) ;; => 'bar
(count D) ;; => 2

The only difference would appear when a "foo-vector" is invoked: Instead of an implied get, it's an implied concat (or some other variadic function, but concat works well for discussion).

(B C D) ;; => [:a :b :c 'foo 'bar 'baz 42 99]

Bonus points: Regular vectors and "foo-vectors" containing the same values would satisfy 'equals'.

(= (vector 1 2 3) (foo-vector 1 2 3)) ;; => true

In all respects, "foo-vectors" B, C, and D are vectors, with the exception that when appearing as the first element of a list (i.e., in the function position), an alternative function is called (in our example, concat) instead of get.

Question: What does foo-vector look like to create this new flavor of vector?

I do not know where to begin researching this problem other than regurgitating terms like IFn, deftype, extends, etc. I greatly appreciate any help.

Aliased namespace in tagged literal

Thu, 11 Dec 2025 20:01:16 +0000

Set up

Tagged literals are defined by setting a namespaced symbol in data_readers.clj (or data_readers.cljc). At load, Clojure merges all of the maps defined in data_readers.clj(c) files found on the classpath into a single map. At read time, the symbol following a # is checked in the merged data readers map, which determines which var to call with the contents of the following form.

For example, #foo/bar [1 2 3] leads to the reader calling the equivalent of (get *data-readers* 'foo/bar).

Problem statement

The tag of a tagged literal must be determined when it is created. The namespace of the chosen tag is set and cannot be changed by a user. Unlike a fully qualified symbol with an aliased namespace, a tagged literal must what was chosen by the author.

As an author of tagged literals, I want to write tags that will not clash with other tags by giving them complex/deep namespaces. For example, {noahtheduke.lazytest/expect noahtheduke.lazytest/expect}.

As a user of tagged literals, I want to alias the namespace of tags and use it in my code. For example:

;; in src/data_readers.clj
{noahtheduke.lazytest/expect noahtheduke.lazytest/expect}

;; in test/noahtheduke/example_project/main-test.clj
(ns noahtheduke.example-project.main-test
  (:require
   [noahtheduke.lazytest :as-alias lt]
   [noahtheduke.lazytest.core :refer [defdescribe it]]))

(defdescribe some-test
  (it "works"
    #lt/expect (= 1 2)))

EDN

This is not related to edn at all and any potential change will be to Clojure itself.

`find` docstring enhancement proposal

Thu, 11 Dec 2025 12:41:48 +0000

The docstring for clojure.core/find states

Returns the map entry for key, or nil if key not present.

Formatted lower-cased with a space, it is not immediately apparent that 'map entry' is a term of art referring to a specific thing. 'map entry' might be mis-interpreted as a casual synonym for 'the entry of a map associated to a key', i.e., the value.

Proposal #1
Reword the find docstring to be more precise about what is returned.

Returns a clojure.lang.MapEntry containing key and the associated value, or nil if key not present.

Proposal #2
If you don't want to make a commitment to returning a MapEntry, reword to

Returns a sequential collection containing key and the associated value, or nil if key not present.

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?

How to use core.async from cljr command line tool?

Mon, 24 Nov 2025 06:05:40 +0000

At some point it would be good to facilitate use of core.async from cljr command line tool (clr.core.cli).

I think what's required is:

add a deps-clr.edn to clojure/tools.analyzer
add a deps-clr.edn to clojure/tools.analyzer.clr (depends on tools.analyzer, clr.tools.reader, clr.core.memoize -> clr.core.cache -> clr.data.priority-map)
add a deps-clr.edn to clojure/clr.core.async
also, archive clojure/clr.tools.analyzer

This is not urgent because it's possible to procure core.async from NuGet but it would be convenient if it could also be procured via git.

clojure.edn/read invoke user-supplied reader functions when tagged literal is to be discarded by discard macro

Thu, 20 Nov 2025 14:57:19 +0000

According to edn-format/edn specification

A reader should not call user-supplied tag handlers during the processing of the element to be discarded.

But with clojure.edn/read and its derivatives execute provided reader functions under discard tag:

user=> (clojure.edn/read-string {:readers {'foo (fn [val] (prn "!!!") val)}} "#_ #foo [1 2 3]")
"!!!"
Execution error at user/eval216 (REPL:1).
EOF while reading

The same happen with clojure.core/read and its derivatives:

user=> (binding [*data-readers* {'foo (fn [val] (prn "!!!") val)}] (read-string "#_ #foo [1 2 3]"))
"!!!"
Execution error at user/eval146 (REPL:1).
EOF while reading

I understand that Clojure' reader does not provide explicit description of what is executed during reading out form to be discarded except "The form following #_ is completely skipped by the reader." but I think it is worth to mention that here.

After realisation that this post is not qualifies as "ask"

To summarize:
Is this a bug in clojure edn specification implementation?
Is the edn specification no longer accurate?

Threading macro with update and when produces incorrect results

Sat, 29 Nov 2025 07:16:52 +0000

Environment:
- ClojureCLR version: 1.12.2
- .NET version: 10
- OS: MacOS 26.1

Description:
The pattern (-> map (update :key #(when % (fn %))))
fails in ClojureCLR but works correctly in Clojure JVM. When chaining multiple updates in a threading macro where the anonymous function contains when, the result is incorrect or causes runtime errors.

Expected Behavior:
Should work identically to Clojure JVM - update with a function that
returns nil should associate nil to the key.
Actual Behavior:
[Crashes/Wrong values/500 errors in web handlers]
Workaround:
Use explicit conditionals instead:

 (let [value (when (:key map) (fn (:key map)))]
    (if value (assoc map :key value) map))'

clojure -X:deps find-versions doesn't sort tags correctly?

Sat, 09 Aug 2025 14:04:34 +0000

When Maven versions include pre-releases, find-versions seems to sort correctly:

> clojure -X:deps find-versions :lib hiccup/hiccup
Downloading: hiccup/hiccup/maven-metadata.xml from clojars
{:mvn/version "2.0.0-alpha1"}
{:mvn/version "2.0.0-alpha2"}
{:mvn/version "2.0.0-RC1"}
{:mvn/version "2.0.0-RC2"}
{:mvn/version "2.0.0-RC3"}
{:mvn/version "2.0.0-RC4"}
{:mvn/version "2.0.0-RC5"}
{:mvn/version "2.0.0"}

However, when a library is git-only with tags and pre-releases exist, they seem to be alpha-sorted instead:

> clojure -X:deps find-versions :lib io.github.seancorfield/deps-new
{:git/tag "v0.7.1-rc", :git/sha "5a6168d"}
{:git/tag "v0.8.0", :git/sha "2f96530"}
{:git/tag "v0.8.1", :git/sha "2859baf"}
{:git/tag "v0.9.0", :git/sha "da2f764"}
{:git/tag "v0.9.0-rc", :git/sha "b32e0f2"}
{:git/tag "v0.10.0", :git/sha "20e82f8"}
{:git/tag "v0.10.1", :git/sha "a90029c"}
{:git/tag "v0.10.1-rc", :git/sha "35159b5"}

Those -rc versions should sort before the full release.

Optimized str function

Mon, 16 Mar 2026 11:12:53 +0000

Opimized version of str function:

(defn my-str
  (^String [] "")
  (^String [^Object x]
   (if (nil? x) "" (. x (toString))))
  (^String [^Object x & ys]
   (let [sb (StringBuilder. (if (nil? x) "" (. x (toString))))]
     (loop [ys (seq ys)]
       (if-not (nil? ys)
         (let [x (.first ys)]
           (if-not (nil? x)
             (.append sb (.toString ^Object x)))
           (recur (.next ys)))))
     (.toString sb))))

Benchmarks:

(let [xs (vec (range 1000))]
    (criterium/bench
      (apply my-str xs)))

Evaluation count : 2577840 in 60 samples of 42964 calls.

         Execution time mean : 23.611394 µs

(let [xs (vec (range 1000))]
    (criterium/bench
      (apply str xs)))

Evaluation count : 1375200 in 60 samples of 22920 calls.

         Execution time mean : 42.015320 µs

false positive warning: "cljs.core/+, all arguments must be numbers"

Tue, 06 Jan 2026 16:51:22 +0000

The inc function below will never receive a nil, but falsely warns that it might:

clj -Sdeps '{:deps {org.clojure/clojurescript {:mvn/version "1.12.134"}}}' -M -m cljs.main -re node
ClojureScript 1.12.134

cljs.user=> (some-> 1 (#(when (pos? %) %)) inc)
WARNING: cljs.core/+, all arguments must be numbers, got [#{nil clj-nil} number] instead at line 1 <cljs repl>
2

Improve javadoc especially for tool usage

Tue, 16 Sep 2025 17:54:13 +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=>

clojure.edn parser will not parse complete file in some cases

Wed, 07 May 2025 12:29:34 +0000

I've noticed that clojure.edn parser will skip rest of the file if it manages to find the first valid token that will complete collection. For example:

;; demo.edn
{
 :foo 1
 :bar 2 }
 :baz 3 
}

with:

(require '[clojure.edn :as edn]
         '[clojure.java.io :as io])

(with-open [r (io/reader "demo.edn")]
  (edn/read (java.io.PushbackReader. r)))

user=> {:foo 1, :bar 2}

It will also ignore rest of the file when the file is clearly malformed:

{
 :foo 1
 :bar 2 }
xxxx yyyy }}}}} {{{{ ((
 :baz 3

it returns again:

user=> {:foo 1, :bar 2}

I was expecting it to throw EOF exception or at least '}' mismatch. Is this behavior by design or a possible bug?

security problems: dos and command execution in org.clojure:clojure by Deserialization

Tue, 16 Jan 2024 10:50:15 +0000

Reporting Vulnerabilities

In org.clojure:clojure, there are some vulnerabilities as following:
- Denial of service attack ( clojure version 1.2.0 - 1.12.0 )

Command execution ( clojure version 1.9.0 - 1.12.0 )

Note that no additional components are required for this vulnerability.

Details:
RCE CallGraph in 1.12.0-a5

CVE:
- CVE-2024-22871

clojure.tools.reader.edn/read can cause incorrect column number for token at end of input

Sat, 01 Mar 2025 16:58:43 +0000

Context
A user reported that rewrite-clj column number metadata can be incorrect for a token at the end of input.

Rewrite-clj uses clojure.tools/reader to read clojure source.
It uses clojure.tools.reader.reader-types/get-column-number to discover the current column offset.

Affected
clojure.tools/reader v1.3.4 through v1.5.0
Clojure only (not ClojureScript)

Env
On Linux using Clojure CLI 1.12.0.1517 with JDK 23.0.2 (temurin)

Symptom
When the element at end of input is a token, after it is read, the column number is one less than it should be.

Setup
Let's setup a playground in foo.clj

(ns foo
  (:require [clojure.pprint :refer [pprint]]
            [clojure.tools.reader.edn :as edn]
            [clojure.tools.reader.reader-types :as rt]))

(defn reader [s]
  (-> s
      rt/string-push-back-reader
      rt/indexing-push-back-reader))

(defn dump-with-cols [s]
  (println "input string:" s)
  (println "colnums:     " (apply str (take (inc (count s)) (cycle [1 2 3 4 5 6 7 8 9 0])))))

(defn read-by-obj [s]
  (with-open [r (reader s)]
    (loop [acc [{:at :bof :col-number (rt/get-column-number r)}]
           obj (edn/read r false ::eof {})]
      (if (not= ::eof obj)
        (recur (conj acc {:after obj :col-number (rt/get-column-number r)})
               (edn/read r false ::eof {}))
        (conj acc {:at :eof :col-number (rt/get-column-number r)})))))

(let [s (first *command-line-args*)]
  (dump-with-cols s)
  (println "parse result:")
  (pprint (read-by-obj s)))

Reproduction
Using clojure.tools/reader v1.5.0:

$ clojure -Sdeps '{:deps {org.clojure/tools.reader {:mvn/version "1.5.0"}}}' \
        -M foo.clj ':bip :bop'
input string: :bip :bop
colnums:      1234567890
parse result:
[{:at :bof, :col-number 1}
 {:after :bip, :col-number 5}
 {:after :bop, :col-number 9}
 {:at :eof, :col-number 9}]

Notice after :bip we see the correct :col-number 5, but after :bop we see the incorrect :col-number 9; it should be :col-number 10.

An incorrect column number occurs for any unwrapped last token, a number:

$ clojure -Sdeps '{:deps {org.clojure/tools.reader {:mvn/version "1.5.0"}}}' \
        -M foo.clj 123
input string: 123
colnums:      1234
parse result:
[{:at :bof, :col-number 1}
 {:after 123, :col-number 3}
 {:at :eof, :col-number 3}]

a symbol:

$ clojure -Sdeps '{:deps {org.clojure/tools.reader {:mvn/version "1.5.0"}}}' \
        -M foo.clj x
input string: x
colnums:      12
parse result:
[{:at :bof, :col-number 1}
 {:after x, :col-number 1}
 {:at :eof, :col-number 1}]

But we get a correct result for syntax wrapped elements:

$ clojure -Sdeps '{:deps {org.clojure/tools.reader {:mvn/version "1.5.0"}}}' \
        -M foo.clj '(x)'
input string: (x)
colnums:      1234
parse result:
[{:at :bof, :col-number 1}
 {:after (x), :col-number 4}
 {:at :eof, :col-number 4}]

Diagnosis
If I dial clojure.tools/reader back to v1.3.3, I don't see the issue:

$ clojure -Sdeps '{:deps {org.clojure/tools.reader {:mvn/version "1.3.3"}}}' \
        -M foo.clj ':bip :bop'
input string: :bip :bop
colnums:      1234567890
parse result:
[{:at :bof, :col-number 1}
 {:after :bip, :col-number 5}
 {:after :bop, :col-number 10}
 {:at :eof, :col-number 10}]

And then bump one version to v1.3.4, I see the issue:

$ clojure -Sdeps '{:deps {org.clojure/tools.reader {:mvn/version "1.3.4"}}}' \
        -M foo.clj ':bip :bop'
input string: :bip :bop
colnums:      1234567890
parse result:
[{:at :bof, :col-number 1}
 {:after :bip, :col-number 5}
 {:after :bop, :col-number 9}
 {:at :eof, :col-number 9}]

There was only one significant change between v1.3.3 and v1.3.4.

Unreading the character at eof is causing the off-by-one issue.

If I change the existing:

  (loop [sb (StringBuilder.)
         ch initch]
    (if (or (whitespace? ch)
            (macro-terminating? ch)
            (nil? ch))
      (do (unread rdr ch)
          (str sb))
      (if (not-constituent? ch)
        (err/throw-bad-char rdr kind ch)
        (recur (doto sb (.append ch)) (read-char rdr))))))))

To:

  (loop [sb (StringBuilder.)
         ch initch]
    (cond
      (or (whitespace? ch)
          (macro-terminating? ch))
      (do (unread rdr ch)
          (str sb))

      (nil? ch)
      (str sb)

      (not-constituent? ch)
      (err/throw-bad-char rdr kind ch)

      :else
      (recur (doto sb (.append ch)) (read-char rdr)))))))

The problem is resolved for me.

Next Steps
Happy to contribute a patch if the above makes sense to you and you think it is worthwhile to fix.

not-found arg for invoking set (and vector)?

Sat, 06 Dec 2025 15:58:45 +0000

Is there a reason that sets (and vectors) don't have a not-found argument for invoke?

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

In ClojureScript it's already implemented:

cljs.user=> (#{:a :b :c} :d :not-found)
:not-found

However not for vector:

cljs.user=>  ([] 0 :not-found)
Execution error (Error) at (<cljs repl>:1).
No item 0 in vector of length 0

If JIRA issue + patch is welcome for this, I'm volunteering.

clojure.repl/source-fn returns nil for :local/root dependencies

Wed, 06 Aug 2025 01:42:07 +0000

Environment

Clojure 1.12.1 REPL with :local/root dependencies in deps.edn
Example: local.lib namespace at /Users/user/projects/repo/src/local/lib.clj

History

Load namespace from :local/root dependency in REPL

Verify function metadata:

(meta #'local.lib/some-function)
=> {:arglists ([arg]),

 :line 42,
 :column 1,
 :file "/Users/user/projects/repo/src/local/lib.clj",
 :name some-function,
 :ns #object [clojure.lang.Namespace 0x123abc "local.lib"]}

Call (clojure.repl/source-fn 'local.lib/some-function) returns nil

Expectation

source-fn should return the source code string for the symbol.

Actual

source-fn returns nil.

Evidence

(.getResourceAsStream (RT/baseLoader) "/Users/user/projects/repo/src/local/lib.clj") returns nil because RT/baseLoader cannot access local filesystem paths, only classpath JAR resources.

Impact

Breaks REPL-driven development workflow for :local/root dependencies. Creates an inconsistent experience between JAR and local dependencies.

.pow bigdec vs bigint

Sat, 26 Jul 2025 09:15:29 +0000

Consider this:

user> (.pow (bigdec 2) 3)
8M

user> (.pow (bigint 2) 3)
Execution error (IllegalArgumentException) at foo/eval10898 (REPL:1093).
No matching method pow found taking 1 args for class clojure.lang.BigInt

Is that an intentional choice in the language?

Note that this works:

user=> (.pow (biginteger 2) 3)
8
user=> (type (.pow (biginteger 2) 3))
java.math.BigInteger

Except the type is not clojure.lang.BigInt, but java.math.BigInteger, which are different types.

Using letfn* for defining corecursive reified implementations

Fri, 27 Jun 2025 10:38:18 +0000

I was finding a way to have co-recursive reified instances, and after looking at the implementation of clojure.lang.Compiler I've found out that this can actually be achieved with letfn*. Consider the following proof-of-concept:

(defmacro thunk [& body]
  `(reify* [clojure.lang.IFn]
      (invoke [this] ~@body)))

(letfn* [g (thunk (+ 1 2 3 (f)))
         f (thunk (+ 1 2 3))]
    (f))

This works, and seems to be faster than other state-based approaches (e.g. using atom to resolve forward declarations).

This said, I recognize that this may not be standard behavior. for instance using (reify* ...) directly in the letfn* bindings will cause the reify* block to be parsed as a MetaExpr which breaks a cast in the implementation of LetFnExpr. For example:

(letfn* [g (reify* [clojure.lang.IFn] (invoke [this] (+ 1 2 3 (f))))
         f (reify* [clojure.lang.IFn] (invoke [this] (+ 1 2 3)))] 
  (f))

But since this would implicitly add metadata to the reify* forms we get this error:

class clojure.lang.Compiler$MetaExpr cannot be cast to class clojure.lang.Compiler$ObjExpr (clojure.lang.Compiler$MetaExpr and clojure.lang.Compiler$ObjExpr are in unnamed module of loader 'app')

The only way I've managed to create a reify* form without metadata is by creating the form in macro, such as the thunk macro defined in the first example.

Is using reify* within letfn* bindings supported? If not, are there any other methods that avoid mutable state that could be employed in similar cases?