Clojure Q&A - Recent questions tagged jira

Improving curl options for CLI install scripts (brew-install)

Mon, 26 Jan 2026 12:39:44 +0000

Hi!

I'm the maintainer for Heroku's Clojure buildpack. It uses the install scripts from clojure/brew-install to install the CLI. I noticed intermittent install failures related to the download of the Clojure tools. I believe most of them could be avoided with a slightly changed curl command line options.

I opened a PR before realizing that PRs will not be accepted, so I'm starting this thread to properly get the discussion going. For reference, the closed PR can be found here: https://github.com/clojure/brew-install/pull/10

I believe these options would improve the download behaviour for all users, but especially when used in automations:

--connect-timeout 3 (https://curl.se/docs/manpage.html#--connect-timeout)
Prevents hanging when server is unreachable.

--fail (https://curl.se/docs/manpage.html#-f)
Exit with error code 22 for HTTP responses with status codes >= 400.

--max-time 60 (https://curl.se/docs/manpage.html#-m)
Maximum time in seconds for the entire transfer operation. Prevents hanging indefinitely with slow connections.

--no-progress-meter (https://curl.se/docs/manpage.html#--no-progress-meter)
Introduced in curl 7.67.0 (Nov 2019). Disables the progress bar for cleaner output. But less drastic than --silent and will still output diagnostic information (i.e. retries).

--retry-max-time 60 (https://curl.se/docs/manpage.html#--retry-max-time)
Retry only within this time period (60 seconds). After this time expires, no more retries will be attempted.

--retry 5 (https://curl.se/docs/manpage.html#--retry)
Introduced in curl 7.12.3 (Dec 2004). Retry up to 5 times on transient errors (timeouts, HTTP 408, 429, 500, 502, 503, 504, 522, 524).

--retry-connrefused (https://curl.se/docs/manpage.html#--retry-connrefused)
Introduced in curl 7.52.0 (Dec 2016). Consider connection refused as a transient error for --retry.

These are obviously opinionated and my ask is not for these options specifically. Happy to get anything that will improve the situation. :)

Manuel

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

bug bigdec

Fri, 05 Dec 2025 05:09:44 +0000

[clojure.edn] Leading zeros in numbers

Thu, 04 Dec 2025 13:31:23 +0000

clojure.edn allow leading zeros ending up reading such number as octal representation. The problem is that it is also allowed to have indefinite amount of leading zeros for octals:

000000000000042  ;; => 34

and when there is a suffix "M" that forces floating point representation the same string become float 42 stripping all leading zeros.

000000000000042M ;; => 42M

At the same time EDN specification forbids integers with leading zeros at all even for floats.
I found a ticket about leading zeros in data.json but I think it should be expanded to cover clojure as well.

In the same scope but origin is in the EDN spec:
float specification allows leading zeroes in exponent and only zeros in fractional parts:

0.00000000...00
0.0e0001

probably because of that clojure.edn read such numbers without error too.

Could we get deref support on ScopedValue?

Tue, 25 Nov 2025 16:26:47 +0000

Following on from this, and since Optional is already being considered, I would like to propose that ScopedValue is considered as well. It is now a standard feature on an LTS release (i.e. 25).

As always, thanks in advance...

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?

Docstring clojure.edn/read-string is misleading

Thu, 20 Nov 2025 15:10:38 +0000

user=> (doc clojure.edn/read-string)
-------------------------
clojure.edn/read-string
([s] [opts s])
Reads one object from the string s. Returns nil when s is nil or empty.
Reads data in the edn format (subset of Clojure data):
http://edn-format.org

opts is a map as per clojure.edn/read

Note Returns nil when s is nil or empty.. But when called with opts without explicit :eof it throws EOF error

user=> (clojure.edn/read-string {} "")
Execution error at user/eval222 (REPL:1).
EOF while reading

And without options it returns nil as expected

user=> (clojure.edn/read-string "")
nil

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?

Typo in clojure.zipper/zipper docstring

Mon, 27 Oct 2025 09:30:17 +0000

The docstring for clojure.zipper/zipper currently contains:

branch? is a fn that, given a node, returns true if can have
children, even if it currently doesn't.

which should be:

branch? is a fn that, given a node, returns true if it can have
children, even if it currently doesn't.

Replace core.async’s internal LinkedList queue with ArrayDeque?

Tue, 02 Sep 2025 08:02:18 +0000

Hi! While reading the channel implementation I noticed the internal queue is a java.util.LinkedList:
https://github.com/clojure/core.async/blob/master/src/main/clojure/clojure/core/async/impl/channels.clj

The common JVM guidance these days is to prefer java.util.ArrayDeque for FIFO/LIFO queues due to better locality and lower GC overhead. For example, the JDK docs state: “This class is likely to be faster than Stack when used as a stack, and faster than LinkedList when used as a queue.”
https://docs.oracle.com/javase/8/docs/api/java/util/ArrayDeque.html
Related SO discussion: https://stackoverflow.com/questions/6163166/why-is-arraydeque-better-than-linkedlist

A few questions for the maintainers:

Was LinkedList originally chosen for a specific reason (e.g., very old JDK compatibility)?
Are there behaviors in channels that specifically rely on LinkedList (e.g., allowing null, I believe channels disallow nil anyway, or particular iterator characteristics), or would ArrayDeque be a drop-in replacement for the add/remove-from-ends operations used?
If we provide a small PR and benchmark showing an improvement (lower allocations / better throughput under contention), would such a change be considered?
Since ArrayDeque is available on Java 8+, and current Clojure/core.async baselines target that or newer, is there any remaining compatibility concern?

Context: there was an older conversation in Clojurians (#clojure) that suggested ArrayDeque could reduce GC pressure under load and that the original choice may have been influenced by older JDKs:
https://clojurians.slack.com/archives/C03S1KBA2/p1526551888000376

If this sounds reasonable, I’m happy to run the core.async test suite, add JMH-style benchmarks focused on channel put/take hot paths, and submit a PR.

Thanks!

tools.build compile-clj capture out/err

Mon, 28 Jul 2025 19:41:29 +0000

When calling compile-clj, a user can pass in :out and :err to capture the output of the compilation call. However, if for some reason the sub-process exits with a non-0, compile-clj throws without returning that output, making it hard to know what went wrong. (see here: https://github.com/clojure/tools.build/blob/2d2f1b05fd84c3cc756221c17fcfb98034b4d65c/src/main/clojure/clojure/tools/build/tasks/compile_clj.clj#L120)

I would find it helpful if the ex-data of the thrown exception included the :out (variable ps-out and :err (variable ps-err) from the process/process call. Then I could have further insight into what went wrong.

Why does a qualified instance method call fails at compile time with NullPointerException if missing target

Mon, 30 Jun 2025 13:33:36 +0000

Has anyone else noticed a lot of Syntax error (NullPointerException) when using the new Class/.instanceMethod syntax? Specifically whenever I forget the first argument like

(fn [] (String/.length))

gets

#error{:cause "Cannot invoke \"clojure.lang.Compiler$Expr.emit(clojure.lang.Compiler$C, clojure.lang.Compiler$ObjExpr, clojure.asm.commons.GeneratorAdapter)\" because \"this.target\" is null",
       :via [{:type clojure.lang.Compiler$CompilerException,
              :message "Syntax error compiling fn* at (/private/var/folders/cr/wpw7hgnx0jj9m33g28rtbpzc0000gn/T/form-init4871175438924650637.clj:1:1).",
              :data #:clojure.error{:phase :compile-syntax-check,
                                    :line 1,
                                    :column 1,
                                    :source "/private/var/folders/cr/wpw7hgnx0jj9m33g28rtbpzc0000gn/T/form-init4871175438924650637.clj",
                                    :symbol fn*},
              :at [clojure.lang.Compiler analyzeSeq "Compiler.java" 7677]}
             {:type java.lang.NullPointerException,
              :message "Cannot invoke \"clojure.lang.Compiler$Expr.emit(clojure.lang.Compiler$C, clojure.lang.Compiler$ObjExpr, clojure.asm.commons.GeneratorAdapter)\" because \"this.target\" is null",
              :at [clojure.lang.Compiler$InstanceMethodExpr emit "Compiler.java" 2060]}],
       :trace [[clojure.lang.Compiler$InstanceMethodExpr emit "Compiler.java" 2060]
               [clojure.lang.Compiler$BodyExpr emit "Compiler.java" 6723]
               [clojure.lang.Compiler$FnMethod doEmit "Compiler.java" 6243]
               [clojure.lang.Compiler$FnMethod emit "Compiler.java" 6045]
               [clojure.lang.Compiler$FnExpr emitMethods "Compiler.java" 4500]
               [clojure.lang.Compiler$ObjExpr compile "Compiler.java" 5136]
               [clojure.lang.Compiler$FnExpr parse "Compiler.java" 4662]
               [clojure.lang.Compiler analyzeSeq "Compiler.java" 7667]
               [clojure.lang.Compiler analyze "Compiler.java" 7360]
               [clojure.lang.Compiler analyze "Compiler.java" 7316]
               [clojure.lang.Compiler$BodyExpr$Parser parse "Compiler.java" 6683]
               [clojure.lang.Compiler$FnMethod parse "Compiler.java" 6022]
               [clojure.lang.Compiler$FnExpr parse "Compiler.java" 4585]
               [clojure.lang.Compiler analyzeSeq "Compiler.java" 7667]
               [clojure.lang.Compiler analyze "Compiler.java" 7360]
               [clojure.lang.Compiler eval "Compiler.java" 7736]
               [clojure.lang.Compiler eval "Compiler.java" 7694]
               [clojure.core$eval invokeStatic "core.clj" 3232]
               [clojure.core$eval invoke "core.clj" 3228]
               [nrepl.middleware.interruptible_eval$evaluate$fn__966$fn__967 invoke "interruptible_eval.clj" 87]
               [clojure.lang.AFn applyToHelper "AFn.java" 152]
               [clojure.lang.AFn applyTo "AFn.java" 144]
               [clojure.core$apply invokeStatic "core.clj" 667]
               [clojure.core$with_bindings_STAR_ invokeStatic "core.clj" 1990]
               [clojure.core$with_bindings_STAR_ doInvoke "core.clj" 1990]
               [clojure.lang.RestFn invoke "RestFn.java" 428]
               [nrepl.middleware.interruptible_eval$evaluate$fn__966 invoke "interruptible_eval.clj" 87]
               [clojure.main$repl$read_eval_print__9248$fn__9251 invoke "main.clj" 437]
               [clojure.main$repl$read_eval_print__9248 invoke "main.clj" 437]
               [clojure.main$repl$fn__9257 invoke "main.clj" 459]
               [clojure.main$repl invokeStatic "main.clj" 459]
               [clojure.main$repl doInvoke "main.clj" 368]
               [clojure.lang.RestFn invoke "RestFn.java" 1526]
               [nrepl.middleware.interruptible_eval$evaluate invokeStatic "interruptible_eval.clj" 84]
               [nrepl.middleware.interruptible_eval$evaluate invoke "interruptible_eval.clj" 56]
               [nrepl.middleware.interruptible_eval$interruptible_eval$fn__997$fn__1001
                invoke
                "interruptible_eval.clj"
                152]
               [clojure.lang.AFn run "AFn.java" 22]
               [nrepl.middleware.session$session_exec$main_loop__1065$fn__1069 invoke "session.clj" 202]
               [nrepl.middleware.session$session_exec$main_loop__1065 invoke "session.clj" 201]
               [clojure.lang.AFn run "AFn.java" 22]
               [java.lang.Thread run "Thread.java" 1447]]}

File and location data on namespaces

Fri, 16 May 2025 14:46:20 +0000

Preamble

Two thoughts:

Namespaces are not tied to files; they can be created and removed as desired. However, both idiomatically and through clojure.core, they are typically tied to files, being specified at the top of a file that shares the same name: src/noahtheduke/splint/rules.clj holds a single namespace noahtheduke.splint.rules, which is declared before all other forms. This is enforced in require and use calls: (require '[noahtheduke.foo.bar :as fb]) will find a file at src/noahtheduke/bar.clj and then once the file is loaded will attempt to find the namespace noahtheduke.bar and raise an error if it does not exist.

In the compiler, DefExpr will add to the created var's metadata location data in the form of :line, :column, and :file. The first two come from the seq and latter from *file*. This allows for introspection and analysis from tooling, and for better error handling in exceptions and messages.

Desired functionality

I have a collection of namespaces. I want to slurp the corresponding files (if they exist) to analyze and modify with rewrite-clj.

Discussion

Right now, I use metadata on vars to find relevant objects in code and then find the file that way:

(defn get-path-from-var [var']
  (let [f (:file (meta var'))
        path (or (some-> f
                         (#(.. (Thread/currentThread)
                               (getContextClassLoader)
                               (getResource %)))
                         (io/file)
                         (str))
                 f)]
    {:path path
     :file (when (and path (.exists (io/file path)))
             (slurp path))}))

However, that requires users to use the defcram macro I've written, which limits the potential for inline-usage of my primary macro compare-output (such as in a deftest).

I want to be able to use *ns* in compare-output to potentially find where the macro is being called, so I can perform the analysis and desired diffing. This would most easily be done by having location metadata on namespaces.

But more importantly than just my library, I think having location metadata on namespaces would be a genuine help for many tools (such as eastwood, tools.namespace, CIDER, kibit, splint, etc).

Solutions

I'm only going to discuss one solution because this is an Ask, not a jira ticket lol.

I think adding the location metadata in the ns macro is the best place to put it. The ns macro is the preferred way to create a new namespace. Creating namespaces with in-ns or create-ns requires additional steps to make the namespace usable, and neither is a macro to hold &form metadata, increasing the work of adding location metadata.

":added" metadata missing from some new public functions in namespace clojure.java.process

Fri, 11 Apr 2025 16:29:23 +0000

These functions in the namespace clojure.java.process are mentioned in the doc string for the namespace, and have doc strings, but do not have metadata {:added "1.12"} as do other new public docstring'ed functions in that namespace:

stdin
stdout
stderr
exit-ref

I did not find any other such functions anywhere else that are new in Clojure 1.12.0 vs. Clojure 1.11.1.

Idiomatic way to use java.util.Optional

Mon, 07 Apr 2025 14:16:59 +0000

Is there an easy way to work with java.utils.Optional values in Clojure? I'm currently using 1.12 so I can say things like (Optional/.orElse foo nil) to convert the optional value to a "normal" value (X or nil), but that and other Optional methods are still sources of tension or boilerplate compared idiomatic Clojure constructs (some-> for example).

If such a way doesn't currently exist, can it be considered for addition to Clojure? Maybe opening up deref to work on Optionals as well.

Docstring typos in clojure.core/bytes, chars, shorts

Thu, 06 Mar 2025 06:54:53 +0000

The docstring of clojure.core/bytes has a minor typo:

"Casts to bytes[]"

which should read byte[]; similarly for the docstrings of chars and shorts.

Given the new array class syntax in Clojure 1.12 perhaps these should be updated to read byte/1, float/1 etc. instead of using Java style syntax?

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.

Breaking change in 1.12.0 - a static field is always preferred to a static function with the same name

Fri, 28 Feb 2025 20:06:59 +0000

In 1.11.4, if a class has a static field and a static method with the same name, attempting to use the method as a function works as expected.

In 1.12.0, the static field is always returned instead.

A CLI reproduction case:

Clojure 1.12.0
user=> (add-lib 'com.badlogicgames.gdx/gdx)
[com.badlogicgames.gdx/gdx com.badlogicgames.gdx/gdx-jnigen-loader]
user=> (import '(com.badlogic.gdx.math MathUtils))
com.badlogic.gdx.math.MathUtils
user=> MathUtils/random
#object[com.badlogic.gdx.math.RandomXS128 0x3df978b9 "com.badlogic.gdx.math.RandomXS128@3df978b9"]
user=> (MathUtils/random)
#object[com.badlogic.gdx.math.RandomXS128 0x3df978b9 "com.badlogic.gdx.math.RandomXS128@3df978b9"]
user=> (MathUtils/random 0 10)
#object[com.badlogic.gdx.math.RandomXS128 0x3df978b9 "com.badlogic.gdx.math.RandomXS128@3df978b9"]


Clojure 1.11.4
user=> (import '(com.badlogic.gdx.math MathUtils))
com.badlogic.gdx.math.MathUtils
user=> MathUtils/random
#object[com.badlogic.gdx.math.RandomXS128 0x71c905a3 "com.badlogic.gdx.math.RandomXS128@71c905a3"]
user=> (MathUtils/random)
0.37632704
user=> (MathUtils/random 0 10)
0

A potential test case:

diff --git a/test/clojure/test_clojure/java_interop.clj b/test/clojure/test_clojure/java_interop.clj
index 4a503884..c99370a3 100644
--- a/test/clojure/test_clojure/java_interop.clj
+++ b/test/clojure/test_clojure/java_interop.clj
@@ -20,7 +20,7 @@
             [clojure.test-helper :refer [should-not-reflect]])
   (:import java.util.Base64
            (java.io File FileFilter FilenameFilter)
-           (java.util UUID)
+           (java.util ArrayList Collections$UnmodifiableCollection UUID)
            (java.util.concurrent.atomic AtomicLong AtomicInteger)
            (clojure.test FIConstructor FIStatic FunctionalTester AdapterExerciser)))
 
@@ -783,6 +783,16 @@
   (def fi-static (FIStatic/numbers (fn [i] (< i 0))))
   (is (= [-2 -1] fi-static)))
 
+(deftest static-field-and-method
+  (let [fv FIStatic/numbers
+        mv0 (FIStatic/numbers)
+        mv1 (FIStatic/numbers neg?)]
+    (is (= [-2 -1 0 1 2] fv))
+    (is (instance? Collections$UnmodifiableCollection fv))
+    (is (= [-2 -1 0 1 2] mv0))
+    (is (instance? ArrayList mv0))
+    (is (= [-2 -1] mv1))))
+
 ;; newDirectoryStream is overloaded, takes ^[Path String] or ^[Path DirectoryStream$Filter]
 ;; so this method will reflect
 (defn get-dir-stream [^java.nio.file.Path dir-path glob-pattern]
diff --git a/test/java/clojure/test/FIStatic.java b/test/java/clojure/test/FIStatic.java
index 8273c357..4a8198ae 100644
--- a/test/java/clojure/test/FIStatic.java
+++ b/test/java/clojure/test/FIStatic.java
@@ -1,13 +1,20 @@
 package clojure.test;
 
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 import java.util.function.Predicate;
 
 public class FIStatic {
 
+    public static List<Integer> numbers = Collections.unmodifiableList(Arrays.asList(-2, -1, 0, 1, 2));
+
+    public static List<Object> numbers () {
+        return new ArrayList<>(numbers);
+    }
+
     public static List<Object> numbers(Predicate<Integer> pred) {
-        List<Integer> numbers = Arrays.asList(-2, -1, 0, 1, 2);
         Object[] filteredNumbers =  numbers.stream().filter(pred).toArray();
         return Arrays.asList(filteredNumbers);
     }

`doseq` and `for` expands body twice

Wed, 26 Feb 2025 23:15:06 +0000

The bodies of doseq and for seem to be duplicated in their expansions.

$ clojure
user=> (defmacro a [] (prn :expand))
#'user/a
user=> (doseq [_ nil] (a))
:expand
:expand
nil
user=> (for [_ nil] (a))
:expand
:expand
()

I found the same problem in ClojureScript. I could not find an existing discussion about this so I'm not sure if this is by design, apologies if so. I'm aware that these macros have a large code footprint and that doseq cannot use closures (the usual way to prevent exponential expansion), but I missed this detail.

This leads to exponential code blowup if these forms are nested. Artificial demonstration:

$ clojure
Clojure 1.12.0
user=> (def counter (atom -1))
#'user/counter
user=> (defmacro a [] (prn :expand (swap! counter inc)))
#'user/a
user=> #(doseq [_ 1] (doseq [_ 2] (doseq [_ 3] (doseq [_ 4] (a)))))
:expand 0
:expand 1
:expand 2
:expand 3
:expand 4
:expand 5
:expand 6
:expand 7
:expand 8
:expand 9
:expand 10
:expand 11
:expand 12
:expand 13
:expand 14
:expand 15
#object[user$eval926$fn__927 0x76563d26 "user$eval926$fn__927@76563d26"]

This might be especially relevant to core.async, where placing go under doseq is idiomatic, since go is expensive in both expansion time and code size.

user=> (time (eval '(doseq [_ nil] (a/go (doseq [_ nil] (a/go (doseq [_ nil] (a/go))))))))
"Elapsed time: 837.230917 msecs"
nil

It also leads to duplicated reflection warnings from the fully expanded forms, which is how I found this problem.

user=> (doseq [_ nil] (Thread/sleep (identity 1)))
Reflection warning, NO_SOURCE_PATH:1:16 - call to static method sleep on java.lang.Thread can't be resolved (argument types: unknown).
Reflection warning, NO_SOURCE_PATH:1:16 - call to static method sleep on java.lang.Thread can't be resolved (argument types: unknown).
nil

I believe the exponential expansion for doseq was introduced in Clojure 1.1.0 with support for chunked seqs with this commit.

$ clojure -Sdeps '{:deps {org.clojure/clojure {:mvn/version "1.0.0"}}}' 
Downloading: org/clojure/clojure/1.0.0/clojure-1.0.0.pom from central
Downloading: org/clojure/clojure/1.0.0/clojure-1.0.0.jar from central
Clojure 1.0.0-
user=> (defmacro a [] (prn :expand))
#'user/a
user=> (doseq [_ nil] (a))
:expand
nil
user=> ^D
$ clojure -Sdeps '{:deps {org.clojure/clojure {:mvn/version "1.1.0"}}}'
Downloading: org/clojure/clojure/1.1.0/clojure-1.1.0.pom from central
Downloading: org/clojure/clojure/1.1.0/clojure-1.1.0.jar from central
Clojure 1.1.0
user=> (defmacro a [] (prn :expand))
#'user/a
user=> (doseq [_ nil] (a))
:expand
:expand
nil
user=>

At first I wasn't sure if this was hopeless, but I think doseq is fixable fusing the chunked and non-chunked cases like so:

(defmacro doseq
  "Repeatedly executes body (presumably for side-effects) with
  bindings and filtering as provided by \"for\".  Does not retain
  the head of the sequence. Returns nil.
  
  Unlike clojure.core/doseq, does not cause exponential macro expansion
  of expressions in bindings or body."
  [seq-exprs & body]
  (#'clojure.core/assert-args
     (vector? seq-exprs) "a vector for its binding"
     (even? (count seq-exprs)) "an even number of forms in binding vector")
  (let [step (fn step [recform exprs]
               (if-not exprs
                 [true `(do ~@body)]
                 (let [k (first exprs)
                       v (second exprs)]
                   (if (keyword? k)
                     (let [steppair (step recform (nnext exprs))
                           needrec (steppair 0)
                           subform (steppair 1)]
                       (cond
                         (= k :let) [needrec `(let ~v ~subform)]
                         (= k :while) [false `(when ~v
                                                ~subform
                                                ~@(when needrec [recform]))]
                         (= k :when) [false `(if ~v
                                               (do
                                                 ~subform
                                                 ~@(when needrec [recform]))
                                               ~recform)]))
                     (let [seq- (gensym "seq_")
                           chunk- (with-meta (gensym "chunk_")
                                             {:tag 'clojure.lang.IChunk})
                           count- (gensym "count_")
                           i- (gensym "i_")
                           in-chunk- (gensym "in-chunk_")
                           recform `(if ~in-chunk-
                                      (recur ~seq- ~chunk- ~count- (unchecked-inc ~i-))
                                      (recur (next ~seq-) nil 0 0))
                           steppair (step recform (nnext exprs))
                           needrec (steppair 0)
                           subform (steppair 1)]
                       [true
                        `(loop [~seq- (seq ~v), ~chunk- nil,
                                ~count- 0, ~i- 0]
                           (let [~in-chunk- (< ~i- ~count-)
                                 ~seq- (if ~in-chunk- ~seq- (seq ~seq-))]
                             (when (if ~in-chunk- true ~seq-)
                               (let [chunked?# (if ~in-chunk- false (chunked-seq? ~seq-))
                                     ~k (if ~in-chunk-
                                          (.nth ~chunk- ~i-)
                                          (if chunked?# nil (first ~seq-)))]
                                 (if (if ~in-chunk- false chunked?#)
                                   (let [c# (chunk-first ~seq-)]
                                     (recur (chunk-rest ~seq-) c#
                                            (int (count c#)) (int 0)))
                                   (do ~subform
                                       ~@(when needrec [recform])))))))])))))]
    (nth (step nil (seq seq-exprs)) 1)))

Clojure 1.12 breaks Serialization for records implementing IFn

Fri, 21 Feb 2025 20:51:39 +0000

If you have a class/record that implements a functional interface AND IFn, serializing it will throw the same error as CLJ-2880. Here's a repro

(let [^java.util.function.Function my-f
      (reify
        Serializable
        java.util.function.Function
        clojure.lang.IFn
        )]
  (with-open [os (java.io.ObjectOutputStream. (java.io.ByteArrayOutputStream.))]
    (.writeObject os my-f)))

Will throw java.io.NotSerializableException. If you comment out clojure.lang.IFn, this code works.

This is a regression from 1.11.

Please consider making tools.build pom.properties reproducible (e.g. the "Generated by" date)

Sun, 16 Feb 2025 18:43:21 +0000

At the moment (in 1.2.24) the pom.properties includes the current date in a comment, making the resulting jars differ. For now, in Debian we're deferring to SOURCE_DATE_EPOCH whenever it's set: https://salsa.debian.org/clojure-team/tools-build-clojure/-/blob/5739183ec76c39453ff267c6ba19c0605eb406b7/debian/patches/0002-write-pom-make-pom.properties-generated-date-reproducible.patch

clojure.zip/next may execute `make-node` up to 3 times

Fri, 14 Feb 2025 10:55:35 +0000

When I traverse a nested structure with a zipper, modify a node deep inside and want to get the whole updated structure back, each time I visit an ancestor node of the modified one, my make-node function is unnecessarily called 3 times by the clojure.zip/next function.

Reviewing the implementation of the next function, I see that storing the result of (up p) in a variable/binding would get me rid of the extra make-node calls (and I have tested that it does).

I identified this issue in a Clojurescript REPL but it looks like it's present in the Clojure implementation, too.

Auto-descending in clojure.data.zip doesn't seem to make a difference

Mon, 10 Feb 2025 11:05:44 +0000

Learning about zippers, I am trying to make sense of the difference between children and children-auto, as documented in the auto-generated docs, however, by reviewing the code and inspecting its history with git-log, it looks like the last reading of this meta property (possibly through the auto? function) was removed by this commit in 2016.

I think I will give up my trying to understand what "auto-descending by tag=" meant when it no longer matters. I would find it good to remove mentions of it from the documentation to save time to future learners like me, or at least clarify that the behaviour of tag= doesn't change with the choice of children v. children-auto.

What could change, anyway, if there is no code sensitive to this metadatum in the library? Is there another library that uses it, or is it targeted only at user code (remembered in a comment to the auto function), or is it just not useful anymore and should the metadatum (the :zip-filter/no-auto? key) be dropped and associated functions (including children-auto) with it?

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

Thu, 06 Feb 2025 13:54:48 +0000

To reproduce:

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

Clojure 1.12.0
user=>

then

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

clojure.data.xml.event: EndElementEvent should provide tag and location-info

Thu, 10 Oct 2024 14:34:39 +0000

Additional information on the EndElementEvent would be very helpful, especially for processing large data in a streaming way.

I would be happy to propose a patch – I've already signed the Contributor Agreement

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

No path in loop recur arg warning

Sat, 21 Sep 2024 13:12:31 +0000

Reflection warnings, such as for reflective method calls, are printed with the full source path (Compiler/SOURCE_PATH). This is different in case of the warning about loop recur args, printed with the source filename only (Compiler/SOURCE):

(set! *warn-on-reflection* true)

(defn reflective-method-call [] (.substring (try "") 0))

(defn boxed-recur-arg [] (loop [i 0] (recur (try i))))

...which prints:

Reflection warning, /home/pawel/dev/project/src/core.clj:22:33 - call to method substring can't be resolved (target class is unknown).
core.clj:24 recur arg for primitive local: i is not matching primitive, had: Object, needed: long
Auto-boxing loop arg: i

IMHO, the path is useful, especially if the filename is generic and inside a dependency.

clj -X:deps find-versions prefers git deps if both git and mvn exist

Wed, 11 Sep 2024 20:16:33 +0000

Environment

clj --version
Clojure CLI version 1.12.0.1479

Source

A chat on Slack where we happened to notice the behaviour.

Scenario

When lib x is both a git dep and a maven dep,
clj -X:deps find-versions :lib x shows only versions from git deps.

Specific example: io.github.clojure/tools.build

As a git dep:

io.github.clojure/tools.build {:git/tag "v0.10.5" :git/sha "2a21b7a"}

As a Maven dep:

io.github.clojure/tools.build {:mvn/version "0.10.5"}

Reproduction

clj -X:deps find-versions :lib io.github.clojure/tools.build

Actual Behavior

Versions from git deps are listed:

{:git/tag "v0.9.4", :git/sha "76b78fe"}
{:git/tag "v0.9.5", :git/sha "24f2894"}
{:git/tag "v0.9.6", :git/sha "8e78bcc"}
{:git/tag "v0.10.0", :git/sha "3a2c484"}
{:git/tag "v0.10.1", :git/sha "5e3b8f3"}
{:git/tag "v0.10.3", :git/sha "15ead66"}
{:git/tag "v0.10.4", :git/sha "31388ff"}
{:git/tag "v0.10.5", :git/sha "2a21b7a"}

Expected Behavior

TBD by Alex, but note that although maven deps exist, they are not listed.

A few ideas to poke at:

Idea One: populate this list with all available versions:

{:mvn/version "0.9.4" :git/tag "v0.9.4", :git/sha "76b78fe"}
{:mvn/version "0.9.5" :git/tag "v0.9.5", :git/sha "24f2894"}
{:mvn/version "0.9.6" :git/tag "v0.9.6", :git/sha "8e78bcc"}
{:mvn/version "0.10.0" :git/tag "v0.10.0", :git/sha "3a2c484"}
{:mvn/version "0.10.1" :git/tag "v0.10.1", :git/sha "5e3b8f3"}
{:mvn/version "0.10.3" git/tag "v0.10.3", :git/sha "15ead66"}
{:mvn/version "0.10.4" :git/tag "v0.10.4", :git/sha "31388ff"}
{:mvn/version "0.10.5" :git/tag "v0.10.5", :git/sha "2a21b7a"}

But maybe that's a bit confusing for users copy/paste-wise.

Idea Two: list all available versions side by side:

{:mvn/version "0.9.4"} {:git/tag "v0.9.4", :git/sha "76b78fe"}
{:mvn/version "0.9.5"} {:git/tag "v0.9.5", :git/sha "24f2894"}
{:mvn/version "0.9.6"} {git/tag "v0.9.6", :git/sha "8e78bcc"}
{:mvn/version "0.10.0"} {:git/tag "v0.10.0", :git/sha "3a2c484"}
{:mvn/version "0.10.1"} {:git/tag "v0.10.1", :git/sha "5e3b8f3"}
{:mvn/version "0.10.3"} {git/tag "v0.10.3", :git/sha "15ead66"}
{:mvn/version "0.10.4"} {:git/tag "v0.10.4", :git/sha "31388ff"}
{:mvn/version "0.10.5"} {:git/tag "v0.10.5", :git/sha "2a21b7a"}

Idea Three: list all available versions sequentially

{:mvn/version "0.9.4"} 
{:mvn/version "0.9.5"} 
{:mvn/version "0.9.6"} 
{:mvn/version "0.10.0"}
{:mvn/version "0.10.1"}
{:mvn/version "0.10.3"}
{:mvn/version "0.10.4"} 
{:mvn/version "0.10.5"} 
{:mvn/version "0.9.4" :git/tag "v0.9.4", :git/sha "76b78fe"}
{:mvn/version "0.9.5" :git/tag "v0.9.5", :git/sha "24f2894"}
{:mvn/version "0.9.6" :git/tag "v0.9.6", :git/sha "8e78bcc"}
{:mvn/version "0.10.0" :git/tag "v0.10.0", :git/sha "3a2c484"}
{:mvn/version "0.10.1" :git/tag "v0.10.1", :git/sha "5e3b8f3"}
{:mvn/version "0.10.3" git/tag "v0.10.3", :git/sha "15ead66"}
{:mvn/version "0.10.4" :git/tag "v0.10.4", :git/sha "31388ff"}
{:mvn/version "0.10.5" :git/tag "v0.10.5", :git/sha "2a21b7a"}

Separate bindable reporting function from clojure.test/report

Tue, 27 Aug 2024 18:38:20 +0000

Set Up

clojure.test is built on the idea that a test will call an assertion function that directly calls a reporting function: is calls report (through do-report). The function report is a multimethod, allowing for adding or overriding keys to allow for implementing alternative reporting styles. It's also dynamic, meant to be rebound if an entirely new reporting system is to be used (TAP, JUnit, etc).

Problem

As discussed in the excellent kaocha source code, these two approaches don't work together, which leads to issues such as kaocha's workarounds (and monkey-patching), leiningen's monkey-patching, Cursive's test runner not always integrating with other tools due to binding report, and others.

Alessandra Sierra wrote about this issue as well when she attempted a follow-up to clojure.test called Lazytest (which I have resurrected over the last year). She ended up not finishing the library, and many other alternatives to Clojure test have not been as successful as one might hope either.

Given that clojure.test is here to stay, it seems prudent to make it easier to use and adapt without changing the fundamental api.

Potential Solution

Separating the "dynamic variable to be rebound" from "the default reporting function" would make it easier for libraries and tools to choose to extend report or replace it entirely, without worrying that they'll clash or run into each other. This can be accomplished by adding a new dynamic variable *reporter* to clojure.test that do-report calls, and defaulting *reporter* to clojure.test/report. (report would stay dynamic so as to not change working code.)

With such a change in place, workarounds such as Leiningen's monkey-patching could simply bind *report* with a new function and not worry about stepping on any other library's toes.

The new array class syntax in 1.12 doesn't seem to be supported by definterface meta tags

Sat, 24 Aug 2024 12:30:36 +0000

Noticed by user yuhan in slack https://clojurians.slack.com/archives/C03S1KBA2/p1724499452475139

❯ clj -Sdeps '{:deps {org.clojure/clojure {:mvn/version "1.12.0-rc1"}}}'
Clojure 1.12.0-rc1
user=> (definterface Foo (^String/1 bar []))
user.Foo
user=> (reify Foo (bar [this]))
Syntax error (ClassNotFoundException) compiling reify* at (REPL:1:1).
java.lang.String.1
user=>

New add-lib in Clojure 1.12 doesn't load data readers brought by the lib

Tue, 20 Aug 2024 20:42:06 +0000

I see that the new add-lib in Clojure 1.12 doesn't call clojure.core/load-data-readers (like clojure.core does on loading) so if you bring libraries that have data-readers you can't use them.

Calling clojure.core/load-data-readers from the repl doesn't solve the issue since it changes *data-readers* root value which is already being shadowed by clojure.main/repl.

$ clj -Sdeps '{:deps {org.clojure/clojure {:mvn/version "1.12.0-rc1"} com.github.flow-storm/flow-storm-dbg {:mvn/version "3.17.2"}}}'
Clojure 1.12.0-rc1
user=> *data-readers*
{trace #'flow-storm.api/read-trace-tag, ctrace #'flow-storm.api/read-ctrace-tag, rtrace #'flow-storm.api/read-rtrace-tag, tap #'flow-storm.api/read-tap-tag, tap-stack-trace #'flow-storm.api/read-tap-stack-trace-tag, flow-storm.types/value-ref #'flow-storm.types/make-value-ref, amalloy/ring-buffer #'amalloy.ring-buffer/read-method}

now with add-lib :

$ clj -Sdeps '{:deps {org.clojure/clojure {:mvn/version "1.12.0-rc1"}}}'                                                             
Clojure 1.12.0-rc1
user=> (add-lib 'com.github.flow-storm/flow-storm-dbg {:mvn/version "3.17.2"})
[...]
user=> *data-readers*
{}
user=> (#'clojure.core/load-data-readers)
{trace #'flow-storm.api/read-trace-tag, ctrace #'flow-storm.api/read-ctrace-tag, rtrace #'flow-storm.api/read-rtrace-tag, tap #'flow-storm.api/read-tap-tag, tap-stack-trace #'flow-storm.api/read-tap-stack-trace-tag, flow-storm.types/value-ref #'flow-storm.types/make-value-ref, amalloy/ring-buffer #'amalloy.ring-buffer/read-method}
user=> *data-readers*
{}

The only way I see to bring in data-readers with add-lib is by starting a sub-repl :

clj -Sdeps '{:deps {org.clojure/clojure {:mvn/version "1.12.0-rc1"}}}'
Clojure 1.12.0-rc1
user=> (add-lib 'com.github.flow-storm/flow-storm-dbg {:mvn/version "3.17.2"})
[...]
user=> (binding [*data-readers* (#'clojure.core/load-data-readers)] (clojure.main/repl))
user=> *data-readers*
{trace #'flow-storm.api/read-trace-tag, ctrace #'flow-storm.api/read-ctrace-tag, rtrace #'flow-storm.api/read-rtrace-tag, tap #'flow-storm.api/read-tap-tag, tap-stack-trace #'flow-storm.api/read-tap-stack-trace-tag, flow-storm.types/value-ref #'flow-storm.types/make-value-ref, amalloy/ring-buffer #'amalloy.ring-buffer/read-method}

which won't work with nrepl tooling.

defn rejects arity with args vector [&form]

Mon, 19 Aug 2024 21:05:00 +0000

Here's the smallest case, but it seems to happen no matter how many other arities are provided or whether list or vector syntax is used for the arity.

user=> (clojure-version)
"1.12.0-rc1"
user=> (defn f [&form])
Unexpected error (IndexOutOfBoundsException) macroexpanding defn at (REPL:1:1).
null
user=> *e
#error {
 :cause nil
 :via
 [{:type clojure.lang.Compiler$CompilerException
   :message "Unexpected error macroexpanding defn at (1:1)."
   :data #:clojure.error{:phase :macroexpansion, :line 1, :column 1, :source "NO_SOURCE_PATH", :symbol defn}
   :at [clojure.lang.Compiler macroexpand1 "Compiler.java" 7551]}
  {:type java.lang.IndexOutOfBoundsException
   :message nil
   :at [clojure.lang.RT subvec "RT.java" 1634]}]
 :trace
 [[clojure.lang.RT subvec "RT.java" 1634]
  [clojure.core$sigs$asig__5505 invoke "core.clj" 235]
  [clojure.core$sigs invokeStatic "core.clj" 259]
  [clojure.core$defn__5514 invokeStatic "core.clj" 317]
  [clojure.core$defn__5514 doInvoke "core.clj" 294]
  [clojure.lang.RestFn applyTo "RestFn.java" 149]
  [clojure.lang.Var applyTo "Var.java" 707]
  [clojure.lang.Compiler macroexpand1 "Compiler.java" 7525]
  [clojure.lang.Compiler macroexpand "Compiler.java" 7598]
  [clojure.lang.Compiler eval "Compiler.java" 7684]
  [clojure.lang.Compiler eval "Compiler.java" 7655]
  [clojure.core$eval invokeStatic "core.clj" 3232]
  [clojure.core$eval invoke "core.clj" 3228]
  [clojure.main$repl$read_eval_print__9240$fn__9243 invoke "main.clj" 437]
  [clojure.main$repl$read_eval_print__9240 invoke "main.clj" 437]
  [clojure.main$repl$fn__9249 invoke "main.clj" 459]
  [clojure.main$repl invokeStatic "main.clj" 459]
  [clojure.main$repl_opt invokeStatic "main.clj" 523]
  [clojure.main$main invokeStatic "main.clj" 668]
  [clojure.main$main doInvoke "main.clj" 617]
  [clojure.lang.RestFn invoke "RestFn.java" 400]
  [clojure.lang.AFn applyToHelper "AFn.java" 152]
  [clojure.lang.RestFn applyTo "RestFn.java" 135]
  [clojure.lang.Var applyTo "Var.java" 707]
  [clojure.main main "main.java" 40]]}

clojure.pprint/pprint converts unquote+deref to unquote-splicing

Mon, 12 Aug 2024 23:25:23 +0000

This is very unusual syntax but pretty-printing it does not round-trip.

$ clj -Sforce -Sdeps '{:deps {org.clojure/clojure {:mvn/version "1.11.4"}}}'
Clojure 1.11.4
user=> (require '[clojure.pprint :as pp])
nil
user=> (-> "~ @a" read-string pp/pprint)
~@a
nil
user=> (-> '~ @a)
(clojure.core/unquote (clojure.core/deref a))
user=> (-> '~ @a pp/pprint with-out-str read-string)
(clojure.core/unquote-splicing a)

Why does clojure.core/newline not respect flush-on-newline?

Wed, 07 Aug 2024 23:09:06 +0000

Calling (newline) appends a newline to the output stream but does not flush it *flush-on-newline* is bound to true (the default).

Instead, only clojure.core/prn mentions *flush-on-newline* in its docstring and the check and (flush) call is explicit there.

Why is this?

Also, println does not mention that it Observes *flush-on-newline* like prn does, and it doesn't hint that it calls prn which does, since it says Same as print followed by (newline) which isn't actually true.

Comparison ops "Return non-nil if..., otherwise false"

Wed, 31 Jul 2024 01:41:56 +0000

The docstring of < (and others) says:

Returns non-nil if nums are in monotonically decreasing order,
otherwise false.

That seems a bit weird since a) they return either true or false and b) false is "non-nil" so it seems misleading / unhelpful.

What is the history for saying "non-nil" rather than true?

Missing documentation for `:while` modifier of `for` and `doseq`

Mon, 01 Jul 2024 13:56:08 +0000

I believe the for and doseq documentation (at least docstrings) fail to explain the semantics of the :while modifier. The existence is documented, but not the behavior.

I would like to request that the doctoring be updated, especially since it behaves in what I believe is a reasonable but counter-intuitive way. I believe a reasonable person would expect that :while false would trigger the for or doseq to exit; however it does not. Rather it causes the inner-most loop containing the :while to exit, but most notably the outer loops continue to iterate.

Another discussion of this can be found here: clojurians

Using integer parameters in deftype annotations

Sun, 30 Jun 2024 18:44:17 +0000

I am trying to use a Java library that uses annotations on Java classes and methods, so I pass to it deftypes with annotated methods. Some of the annotations require using integer parameters and it seems there is no convenient way to do this in Clojure. The code I am trying is something like this:

(deftype SomeType []
  (^{Retention RetentionPolicy/RUNTIME
     SomeAnnotationClass {:order 1} }
   someMethod [_]...))

The :order 1 part causes an exception:

Incorrectly typed data found for annotation element ... (Found data of type java.lang.Long[1])

This happens because the java library expects that :order would have a java.lang.Integer value, but Clojure creates a java.lang.Long. If I try (int 1) instead of 1, I get another exception.

I asked for help on clojurians Slack, and it was suggested that I use #java.lang.Integer[1] instead of simply 1. This works, but it would be nice to have a more intuitive way to do this.

Locals clearing + forcing a delay recursively results in NPE

Thu, 30 May 2024 21:11:28 +0000

Discovered by Ambrose Bonnaire-Sergeant (@ambrosebs).

Given this convoluted example:

(let [f +
      p (promise)
      d (delay (f) @@p)]
 (deliver p d)
 @d)

When executed, it fails with:

1. Unhandled java.lang.NullPointerException
   Cannot invoke "clojure.lang.IFn.invoke()" because "this.f" is null

The same error happens with lazy seqs:

(let [f +
      p (promise)
      d (lazy-seq (f) (first @p))]
  (deliver p d)
  (first d))

The reason in both cases is that locals clearing assigns this.f = null; right after it is first invoked, so when the recursive call reaches (f) again, the reference is already nil.

(binding [*compiler-options* {:disable-locals-clearing false}]
  (clj-java-decompiler.core/decompile
   (defn repro []
     (let [f +
        p (promise)
        d (delay (f) @@p)]
    (deliver p d)
    @d))))

=>

@Override
public Object invoke() {
    final Object f = this.f;
    this.f = null;
    ((IFn)f).invoke();
    final IFn fn = (IFn)__deref.getRawRoot();
    final IFn fn2 = (IFn)__deref.getRawRoot();
    final Object p = this.p;
    this.p = null;
    final Object invoke = fn2.invoke(p);
    this = null;
    return fn.invoke(invoke);
}

Is this a bug or undefined behavior?

Expand FI adapting to SAM types (not marked as FI)

Fri, 24 May 2024 12:50:20 +0000

There are a lot of SAM types that are not FI in the JDK - some prominent ones are Executor, ThreadFactory, etc. Increasing the scope of what we adapt would allow us to be closer to Java’s support and would expand the scope of where this support can be used.

Simple example:

;; Adapt Thread constructor method value to ThreadFactory (not FI)
;; Use the factory to get a Thread with a Runnable and start it
(let [^java.util.concurrent.ThreadFactory tf ^[Runnable] Thread/new]
  (.start 
    (.newThread tf #(println "hi"))))

Execution error (ClassCastException) at user/eval145 (REPL:1).

class user$eval145$invoke__Thread_new__149 cannot be cast to class java.util.concurrent.ThreadFactory

Jira: https://clojure.atlassian.net/browse/CLJ-2856

Support Clojure 1.12-alpha12 Array class notation

Thu, 23 May 2024 19:02:29 +0000

Currently, the function clojure.tools.reader.impl.commons/parse-symbol is fairly lax with what it allows, both in general and with regard to the forthcoming Clojure 1.12 Array class notation.

user=> (mapv trc/parse-symbol ["String/1" "String/-1" "String/11" "String/1a"])
[nil ["String" "-1"] nil nil]

This is different than the current implementation, which only accepts the first. Is there any interest in updating it to be stricter for the new notation?

Could re-pattern be extended to allow flags?

Wed, 22 May 2024 17:02:15 +0000

The JVM method java.util.regex.Pattern has the option of taking a second parameter for flags, which is a bitwise combination of the various allowed values. Has a similar arity been considered for the clojure.core.re-pattern function?

For instance:

(def rflags {\i java.util.regex.Pattern/CASE_INSENSITIVE
             \m java.util.regex.Pattern/MULTILINE
             \s java.util.regex.Pattern/DOTALL
             \u java.util.regex.Pattern/UNICODE_CASE
             \d java.util.regex.Pattern/UNIX_LINES
             \x java.util.regex.Pattern/LITERAL
             \c java.util.regex.Pattern/CANON_EQ})
(defn re-flags [s] 
  (reduce bit-or 0 (map #(rflags % 0) s)))

(defn re-pattern
  "Returns an instance of java.util.regex.Pattern, for use, e.g. in
  re-matcher."
  {:tag java.util.regex.Pattern
   :added "1.0"
   :static true}
  ([s] (re-pattern s 0))
  ([s f] (if (instance? java.util.regex.Pattern s)
          s
          (. java.util.regex.Pattern (compile s f))))

Some notes on this:
- Most of these flags can already be added to a pattern today using a ? modifier. For instance, a pattern can be made case insensitive by adding (?i) to the start of the string. However, allowing a flags string is compatible with JavaScript (and could be implemented on ClojureScript)
- There are currently no options to define LITERAL or CANON_EQ without using java.util.regex.Pattern directly.
- There is currently no way to implement any flags in ClojureScript without using interop.
- While not all of these flags are compatible with JavaScript, the more common ones are. Similarly, JavaScript allows for flags that are not compatible with Java, so there is already a small disconnect.
- Passing 0 for the default flags is indeed what java.util.regex.Pattern(String) does.

tools.tools install-latest throws sha error with :coord and never upgrades with :tool

Mon, 13 May 2024 10:24:47 +0000

Thanks for https://clojure.atlassian.net/browse/TDEPS-253, however I noticed it doesn't quite work as expected for a fresh install (with :coord); I get an error due to a missing sha, contrary to the doc string "git coords may omit sha".

clj -Ttools install-latest \
:lib org/tool-name \
:coord '{:git/url "git@gitlab.int.org.com:group/subgroup/tool-name.git"}' \
:as tool-name

=>
Execution error (ExceptionInfo) at clojure.tools.deps.extensions.git/eval1656$fn (git.clj:79).
Library org/tool-name has coord with missing sha

I also found upgrading a tool with saved coordinates (clj -Ttools install-latest :tool tool-name) always results in "Skipping, newest installed" (because passing the coord returned by parse-install-latest-args to install-1 means ext/find-all-versions is never evaluated). Looks like this issue would affect tools with auto resolved git urls too.

`(s/gen ratio?)` throws exceptions

Wed, 08 May 2024 07:44:49 +0000

(s/gen ratio?) is implemented as (gen/such-that ratio? gen/ratio)

The problem is that about 10% of the time gen/ratio returns a whole number, which fails the ratio? predicate. If that happens 10 times in a row, gen/such-that throws an exception.

With a large enough sample size, (s/gen ratio?) reliably fails:

(dorun (gen/sample (s/gen ratio?) 10000000))

Execution error (ExceptionInfo) at clojure.test.check.generators/fn (generators.cljc:435).
Couldn't satisfy such-that predicate after 10 tries.

A quick fix is to increase the max-tries param for such-that:

(dorun (gen/sample (gen/such-that ratio? gen/ratio 100) 10000000))

=> nil

I do however also find it odd that (s/gen ratio?) always generates Ratios, but gen/ratio generates a mixture of ratios and integers. So perhaps a better fix would be to update gen/ratio to not generate integers?

Request: def should infer type tag where possible

Fri, 03 May 2024 20:01:21 +0000

Maybe there’s a good reason why it doesn’t, but it seems to me it would be great if def would automatically infer type hint:

(let [s "abc"]
  (.chars s)) ;; all fine, no warning

(def s "abc")

(.chars s) ;; Reflection warning, null:21:0 - reference to field chars can't be resolved.

(meta #'s) ;; ↓ notice -- no tag
;; {:line 19,
;;  :column 0,
;;  :file "NO_SOURCE_FILE",
;;  :name s,
;;  :ns #object[clojure.lang.Namespace 0x78068afb "user"]}

Why does compilation of fn fail when referencing a class with a failing static field initializer?

Mon, 08 Apr 2024 15:01:01 +0000

Given a Clojure function which references a class, if that class has a static field with an initializer which fails when run, the function will fail to compile because the compiler (needlessly) runs the initializer even if the respective field is not accessed. Notably, this does not happen when storing the class in a var and then referencing it through that instead (see workaround below). Could the compiler support the direct reference here?

Reproducer

(The following code is also available at https://github.com/bevuta/clojure-fn-compilation-issue-repro)

deps.edn:

{:deps {io.netty/netty-codec {:mvn/version "4.1.108.Final"}}}

src/repro/fail.clj:

(ns repro.fail
  (:import io.netty.handler.codec.compression.BrotliOptions))

(defn bar []
  BrotliOptions)

(defn -main [& args]
  (prn (bar)))

Here, the bar function references the io.netty.handler.codec.compression.BrotliOptions class. That class has a package-private static field named DEFAULT with an initializer. That initializer depends on a class which is provided by an optional third-party library. However, even though bar never references that field, the initializer gets run and fails because that library is not present.

Run it like this:

$ clojure -M -m repro.fail
Execution error (ClassNotFoundException) at jdk.internal.loader.BuiltinClassLoader/loadClass (BuiltinClassLoader.java:641).
com.aayushatharva.brotli4j.encoder.Encoder$Parameters

Workaround

The issue can be worked around by putting the class value into a separate def and using that in the function instead:

src/repro/ok.clj:

(ns repro.ok
  (:import io.netty.handler.codec.compression.BrotliOptions))

(def foo BrotliOptions)

(defn bar []
  foo)

(defn -main [& args]
  (prn (bar)))

Run it like this:

$ clojure -M -m repro.ok
io.netty.handler.codec.compression.BrotliOptions

Relevance

The issue was encountered in the context of https://github.com/clj-commons/aleph/issues/703

java.lang.NoClassDefFoundError: java/util/SequencedCollection

Wed, 21 Feb 2024 03:29:09 +0000

Compiling a deftype that implements List on Java 21 will create a class that includes a reference to the (new to Java 21) SequencedCollection type (which introduces a new method reverse). Loading the compiled class will throw in an older Java runtime as the SequencedCollection type doesn't exist.

Given repro.clj:

(ns repro)

(deftype C []
  java.util.List)

Compiling with Java 21 JDK to a class, javap shows:

public final class repro.C implements java.util.List,clojure.lang.IType {
  public repro.C();
    Code:
       0: aload_0
       1: invokespecial #13  // Method java/lang/Object."<init>":()V
       4: return

  public static clojure.lang.IPersistentVector getBasis();
    Code:
       0: invokestatic  #20  // Method clojure/lang/Tuple.create:()Lclojure/lang/IPersistentVector;
       3: areturn

  public java.util.SequencedCollection reversed();
    Code:
       0: aload_0
       1: invokeinterface #25,  1   // InterfaceMethod java/util/List.reversed:()Ljava/util/List;
       6: areturn

  public static {};
    Code:
       0: return
}

Loading this class in Clojure with an older Java version throws:

user=> (require 'repro)
Execution error (ClassNotFoundException) at jdk.internal.loader.BuiltinClassLoader/loadClass (BuiltinClassLoader.java:641).
java.util.SequencedCollection

List includes a default reversed() method implementation for the SequenceCollection parent interface. Not sure why this forwarding method is getting created here but it's presumably different than others because it's a parent default method impl that we're forwarding to.

Option in `clojure` CLI command to print the basis

Thu, 15 Feb 2024 13:57:44 +0000

It would be nice that clojure could print the basis for a given combination of aliases (or none).

A common use case is obtaining the computed :paths for a combination of aliases.

spec for extend-protocol

Wed, 14 Feb 2024 14:05:57 +0000

Many macros in clojure have a spec which get executed by the compiler at macro-expansion time.

At this time extend-protocol doesn't have such a spec.
I'd like to know if extend-protocol is supposed to work with (Class/forName ..) or that the class name to which the protocol is extended must always be a symbol. A spec would be the natural place to get this answer from. extend-protocol is known to not work with Class/forName when you provide more than one:

(extend-protocol IFoo (Class/forName "[B") (Class/forName "[D")) Syntax error (IllegalArgumentException) compiling at (REPL:1:1). Don't know how to create ISeq from: java.lang.Character

If the spec says anything about this, I can also make linting for this in clj-kondo. At this time it seems to be ambiguous: (extend-protocol IFoo (Class/forName "[B")) does work.

Does `:exclude` need to be added to https://clojuredocs.org/clojure.core/require ?

Tue, 13 Feb 2024 19:29:06 +0000

https://clojuredocs.org/clojure.core/require makes no mention of :exclude but this seems to work as it appears:

(require '[clojure.set :refer :all :exclude [join rename]])

Should 'method value' error messages (wrong arity) special case for constructors?

Mon, 12 Feb 2024 23:36:52 +0000

If I call a method with the wrong number of arguments, I get a concise, descriptive error message:
(^[] String/toUpperCase "foo" 2) Syntax error... Invocation of method toUpperCase in class java.lang.String expected 0 arguments, but received 1

If I call a constructor with the wrong number of arguments, I get a very similar message:
(^[String] String/new "foo" 2) Syntax error... Invocation of method java.lang.String in class java.lang.String expected 1 arguments, but received 2

This message refers to the class name as the method, which feels like what you might get for a constructor.

I noticed that if my param-tags are incorrect on a constructor, the wording of the message is slightly different ("Expected to find 1 matching signature for constructor" as opposed to "for method"), so I just want to pose the question while these messages are somewhat fresh: Should the wording for the arity message mention 'constructor' or 'String/new' or something along those lines?