Clojure Q&A - Recent questions without answers

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

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

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

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

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

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

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

Thank you!

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

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

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

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

definterface doesn't expose this.

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

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

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

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

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

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

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

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

non-octal characters:

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

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

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

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

`pipeline-blocking` uses `thread` internally instead of `io-thread`

Wed, 29 Oct 2025 15:54:00 +0000

pipeline-blocking is explicitly meant for blocking operations (implying I/O). However, internally it uses thread rather than io-thread for processing: https://github.com/clojure/core.async/blob/master/src/main/clojure/clojure/core/async.clj#L637-L640.

Since 1.9.829-alpha2 this has practical implications, as only io-thread will utilize virtual threads, when available.

Can this be fixed / changed?
If not, can an explicit pipeline-io (or similar) function be added to support this use case?

Thanks

Choosing between core.async pipelines

Sun, 26 Oct 2025 22:19:12 +0000

It's no longer clear what kind of pipeline is suitable for what kind of task in core.async.

Previously, my understanding was that anything I/O-bound should go into pipeline-blocking, while CPU-bound tasks went into regular (i.e. :compute) pipeline. But a while back :compute pipelines were changed to use threads instead of go-blocks. And now, with the introduction of virtual threads, pipeline-async seems like the right choice for I/O-bound tasks.

It seems that workloads are being classified into one of three types: :compute, :io, and :mixed. Is :async meant to be the equivalent of :io, and :blocking the equivalent of :mixed? I don't think that's original semantics, but it seems to be the mapping now.

Allocation churn on generators

Tue, 07 Oct 2025 21:16:10 +0000

When generating moderately large values there is some LazySeq churn that could be avoided. For example, the following snippet allocates over 15GB (measured with async-profiler):

(core/let [g (vector (not-empty string-alphanumeric) 1000 5000)]
  (time
   (dotimes [seed 50]
     (dorun (generate g 100 seed)))))

The pattern of generating multiple (increasingly larger) values is common with quick-check (via deftest et al).

Many generators are built on top of choose, and there is an opportunity to reduce churn by special casing shrink-int for longs (which should be the common case compared to big ints).

I have a patch that decreases total allocations of the repro above by ~15% and speed up the run time by ~25% (measured on jdk 25, with -Xmx512m -XX:+UseSerialGC to decrease variance). Happy to share it.

`(s/gen ...)` caches its failure to load generators and thus is incompatible with `add-lib`

Tue, 23 Sep 2025 16:23:58 +0000

Clojure 1.12.0
user=> (require '[clojure.spec.alpha :as s])
nil
user=> (s/def ::x #{1 2 3})
:user/x
user=> (s/gen ::x)
Execution error (FileNotFoundException) at user/eval145 (REPL:1).
Could not locate clojure/test/check/generators__init.class, clojure/test/check/generators.clj or clojure/test/check/generators.cljc on classpath.
user=> (add-lib 'org.clojure/test.check)
[org.clojure/test.check]
user=> (s/gen ::x)
Execution error (FileNotFoundException) at user/eval145 (REPL:1).
Could not locate clojure/test/check/generators__init.class, clojure/test/check/generators.clj or clojure/test/check/generators.cljc on classpath.

Possible ClojureScript bug: corner case with regex literal compilation

Sun, 21 Sep 2025 02:59:22 +0000

I've found what I believe to be a bug in ClojureScript regarding compilation of certain regex literals to JavaScript, a specific example being #"(?i)".

In some cases, #"(?i)" will be compiled to the JavaScript syntax //i, which is in fact not a JavaScript regex literal, but rather a JavaScript single line comment. This then comments out all remaining code on the same generated line, resulting in a syntax error when the code is run on a JavaScript runtime.

This minimal unit test example demonstrates the issue:

(ns regex-test
(:require [cljs.test :refer-macros [deftest testing is]]))

(deftest failing-test
(testing "Minimal reproduction"
(is (not (nil? #"(?i)")))))

As a side note, it's worth mentioning that (?i) is not a valid native JavaScript regex in the first place, so I assume ClojureScript is trying to emulate compatibility with JVM regexes (where this is valid), and converting it to the nearest valid JS equivalent - either (?i:) (e.g. at the REPL), or //i (in compiled code, but which is syntactically not a JS regex literal at all).

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 -X hangs with agent use

Wed, 10 Sep 2025 21:02:32 +0000

Given this repro:

(ns repro)

(defn exec-fn [_]
  (let [a (agent nil)]
    (prn (-> (java.lang.ProcessHandle/current) (.pid)))
    (send a (fn [_] 3))))

the clojure -X repro/exec-fn invocation is hanging.

This seems to be unintentional, given that clojure -X doesn't wait for futures to finish either?

Porting clojure libraries w/ java interop to clojure-clr

Fri, 15 Aug 2025 01:31:53 +0000

I've been browsing around to understand the ecosystem.

I see some libraries are ported to use CLR interop, like core.logic, some are part way finished, like core.async.

Here is one maintainer's concerns, they would much like to point CLR users at a fork with CLR interop maintained by someone else:
https://github.com/weavejester/medley/pull/96
https://github.com/weavejester/medley/pull/65

For fun I examined how to use formal logic to do the code translation. Using Spec, and core.logic for code generation perhaps. I think it would require a lot of knowledge representation.

It might be easier, for these non-core/crucial libraries to use LLMs to do the code translation, and direct the outputs into a set of forks. Perhaps the core libraries used as training data on what to do. This author has some great insights and details on a plausible workflow(s) including with the utility of editor integration. He has done interop translation and work with clojure:
https://m.youtube.com/watch?v=oNhqqiKuUmw

As it is only the interop which requires translation (subsets of clojure files), with a skilled hand there might be better results than some of what he illustrates.

I looked around for a spec for the dotnet core API. I saw one they used to maintain but couldn't find a recent one. Though, all this LLM stuff is beyond me at this time. I thought to share some of my exploration.

EDIT: Found the dotnet API spec/reference for netstandard 2.1.0, I think someone wrote they since moved it into dotnet/runtime but I couldn't find it there, dunno if this helps: https://github.com/dotnet/standard/blob/v2.1.0/src/netstandard/ref/System.IO.cs

select-keys on nil map

Fri, 01 Aug 2025 14:42:56 +0000

I know that https://ask.clojure.org/index.php/1913/use-transients-with-select-keys-if-possible exists to optimize select-keys for many keys, but I noticed that it does a lot of work even if the original map is nil. Would there be interest in a patch that returns an empty map when given nil? Something like:

(defn select-keys*
  "Returns a map containing only those entries in map whose key is in keys"
  {:added "1.0"
   :static true}
  [map keyseq]
  (if map
    (loop [ret {} keys (seq keyseq)]
      (if keys
        (let [entry (. clojure.lang.RT (find map (first keys)))]
          (recur
           (if entry
             (conj ret entry)
             ret)
           (next keys)))
        (with-meta ret (meta map))))
    {}))

Compiler-generated `foo__init.class` files lack `SourceFile` attribute

Thu, 31 Jul 2025 22:21:18 +0000

Most .class files generated by Clojure contain the expected SourceFile attribute (you can verify with javap -v). But __init classfiles lack this metadata. I asked @alexmiller on Slack, and he suggested I bring it up here.

The same appears to be true of classes generated via proxy.

Skip stacktrace creation in ExceptionInfo

Thu, 17 Jul 2025 14:46:52 +0000

Many libraries and applications use exceptions as control flow or data collection, which allows for handling complex situations with more consistent and legible code. Some libraries use custom throwables (IGJoshua/farolero, NoahTheDuke/lazytest) and some use ExceptionInfos (scgilardi/slingshot, fmnoise/flow, pangloss/pure-conditioning, exoscale/ex).

One of the reasons that libraries reach for custom throwables is because they want to skip creation of a stack trace (which isn't used and would be thrown away immediately). Stack traces in Java are already fairly expensive to create, and then the filtering work done in ExceptionInfo greatly increases that expense, making them much slower than needed. (There's an Ask about this but I can't find it.) This performance cost pressures developers to use custom throwables if their code will ever be used in a "hot path", which harms portability and ease of development. (I want to write Clojure, not Java, and I want it to be usable in Clojurescript and Babashka and whatever other dialects might arise.)

I know that there's a rejected Jira ticket (CLJ-2423) for supporting the "enableSuppression" flag, but in light of these use-cases, I'd like to bring it up again.

How best to call long-running tasks from a core.async.flow process?

Wed, 09 Jul 2025 18:31:41 +0000

I'd like to write to a database as the final process in a core.async.flow flow. The db load can take several minutes. If I do this work directly in the :transform function's thread, flow-monitor can't ping that process for the duration of the load. But if I offload the work to a different thread and return from the :transform function, I can't as easily control back pressure from that process.

The relevant process currently looks something like:

(def db-loader
  (flow/map->step
   {:describe (fn [] {:workload :io
                      :ins {:in "Batched items"}})
    :init     (fn [state] state)
    :transition (fn [state status] state)
    :transform (fn [state _ batch]
                 (t/log! "DB Loader is loading a batch.")
                 (Thread/sleep 10000) ;; imagine this code writes to the db.
                 (t/log! "DB Loader loaded a batch.")
                 [state])}))

A more complete code example is at https://gist.github.com/tomconnors/245fb69ed757b34502c8d57637db8de2.

Is there a better option for this process?

Metadata on quoted forms

Sun, 06 Jul 2025 15:29:14 +0000

Reader metadata is attached to IObj forms at read time, but if the form is quoted, then the quote form gets the metadata and the quoted form doesn't get the metadata. This means that to attach metadata to forms, you need to write the slightly awkward quote -> metadata -> form instead of the (imo) more natural metadata-> quote -> form.

user=> (meta ^:foo '(1 2 3))
{:line 1 :column 1}
user=> (meta '^:foo (1 2 3))
{:lime 1 :column 1 :foo true}

I know that this is because ' is implemented as a "WrappingReader" and so the former is read as ^:foo (quote (1 2 3)) but that feels like an implementation detail leaking through. I think it would be helpful/more consistent if quote passed any metadata to IObjs.

POSIX-style command line arguments in tools (-T)

Thu, 03 Jul 2025 21:06:46 +0000

I have a couple command line tools written as libraries that I'd like to expose as proper Clojure Tools. They have classic POSIX-style command line interfaces, relying on tools.cli. I could add an -X kv-map interface, but there are a number of boolean flags that would not translate well to :foo true style (such as arbitrary file paths).

Is there a way to pass arbitrary arguments to a clojure Tool without using the kv-map style?

And if not, would there be interest in a flag or option that would allow for such a thing?

`create-basis` silently accepts missing aliases

Tue, 10 Jun 2025 00:57:37 +0000

In this scenario, the alias for create-basis was incorrect, preventing security deps overrides from being applied. For 2 years clojars was deployed with these vulnerable deps.

In this case, I proposed to inline the alias into :deps. However there may be other scenarios where a tools.deps change might be helpful to catch these mistakes earlier, for example a warning or error.

Improve clojure cli error msg: "The following libs must be prepared" could include "clojure -X:deps prep"

Sun, 08 Jun 2025 17:57:20 +0000

This happens basically every time I add a dependency that needs prepping. I see the error, but don't have the prep command memorized so I have to look it up. It would be very helpful if the error printed also included the command invocation for prepping, clojure -X:deps prep.

`(even? (range))` hangs

Sun, 08 Jun 2025 11:54:29 +0000

It is, of course, an error to call (even? (range)), but still - I'd much rather prefer a class cast exception. Or the existing IllegalArgumentException, just without printing the argument. Especially given that the argument could be absolutely anything, including side-effecting lazy collections.

A couple of other cases like this:

(array-map (range))
(requiring-resolve (range))

Associative destructuring with if-let

Sat, 07 Jun 2025 17:21:45 +0000

Hello,

I'm surprised by the result of this code :

(if-let [{errors :errors} {}]
    errors
    true) => nil

I would have expected the result to be 'true'.

As indicated by the result, 'errors' evaluates to nil, but still it's the 'then' arm of the 'if' that is evaluated.

The guide on destructuring state that "You can utilize destructuring anywhere that there is an explicit or implicit let binding.", so I'm a bit puzzled.

Please, enlighten me. Thanks !

regular expression with Classes for Unicode scripts, blocks, categories and binary properties

Tue, 22 Apr 2025 15:39:14 +0000

In Clojure, the following expression works fine:

(re-matches #"\p{Lu}" "Á") ;; => "Á"

But in Clojurescript, it returns nil.

It is not that Javascript doesn't support that kind of Unicode classess, but you have to activate them explicitly, whether in Java, they are activated by default.

E.g. In Javascript, the following code returns true:

/\p{Lu}/u.test("Á") // => true

But if I omit the Unicode flag (/u) I get false:

/\p{Lu}/.test("Á") // => false

I think this is probably because Clojure Script doesn't activates the Unicode flag for us.

If that the case, I think consistency between Clojurescript and Clojure could benefit a lot if the flag is activated by default.

Does clojure-clr work on Android?

Sat, 19 Apr 2025 19:59:28 +0000

EDIT: Answer is YES. Below is my long-winded exploration.

I see one of the reasons for clojure-clr-next is it will work on more platforms, is Android one of those?

I'm using Termux to operate dotnet on Android.

Both the clojure-clr global dotnet tool and locally compiled clojure-clr fail with exit code 1, no exceptions or anything. I tried dotnet-trace and it gets a partial trace, but no minidump. Puzzling as with the partial trace, the documentation indicates an expectation of a minidump, maybe there is some unmet condition to emit the minidump I'm not aware of yet (env variables for it didn't work).

In the trace here is an early line followed by some of the last lines:
`
"system.linq!System.Linq.Enumerable.SelectManyS\ingleSelectorIterator\u003cSystem.Reflection.As\sembly,System.Type\u003e.MoveNext()"

[...]
"system.collections!System.Collections.Generic.\
SortedSet\u003cSystem.Collections.Generic.KeyVa\luePair\u003cSystem.Int32,clojure.lang.CljCompi\ler.Ast.FnMethod\u003e\u003e.AddIfNotPresent(Sy\stem.Collections.Generic.KeyValuePair`2\u003cin\t,

[...last line...]
"ManagedModule!System.Buffers.SharedArrayPool\u\003cSystem.Byte\u003e.Trim()"
`

So maybe something to do with reflection, or that SharedArrayPool?

I tried inserting some logging to Clojure.Main, but nothing logged as it appears to fail before CljMain.Main() is called. Possibly fails during setting up attributes on one of the classes, in one of the Symbol.intern() or RT.var() calls or somewhere else?

Couldn't run the dotnet msbuild build.proj -t:Test -p:TestTargetFramework=net8.0, fails with:
Clojure.Main -> /data/data/com.termux/files/home/dev/clojure-clr/Clojure/Clojure.Main/bin/Debug/net8.0/Clojure.Main.dll ClojureCompileAssets = '' ClojureMainAssets = '' ClojureTestsAssets = '' /data/data/com.termux/files/home/dev/clojure-clr/Clojure/build.proj(177,5): error MSB3073: The command "dotnet run --project /data/data/com.termux/files/home/dev/clojure-clr/Clojure/Clojure.Main --framework net8.0 -c Debug -p:TargetOS=linux-bionic -p:TargetPlatform=arm64 -p:TargetFramework=net8.0 -p:TargetFrameworks='net8.0' -- run_test.clj" exited with code 1.
I had to edit build.proj a bit to get custom -p:TargetFrameworks and such to pass through, but still fails with exit code 1.

Well I'll continue poking around in this uncharted territory.

Is cljs.test swallowing exceptions?

Fri, 18 Apr 2025 16:09:48 +0000

Hi! Thanks for ClojureScript - we're using it more and more and it's amazing.

Something has been bothering me about testing in the repl, and I figured out what it is today.

Check this out:

harold@straylight:~/src/cljs-test-exception$ cat deps.edn 
{:deps {org.clojure/clojurescript {:mvn/version "1.11.132"}}}
harold@straylight:~/src/cljs-test-exception$ clj -M --main cljs.main --repl
ClojureScript 1.11.132
cljs.user=> (require '[cljs.test :refer [deftest]])
nil
cljs.user=> (deftest foo [] (throw (js/Error. "oops!")))
#'cljs.user/foo
cljs.user=> (foo)

ERROR in (foo) (Error:NaN:NaN)
Uncaught exception, not in assertion.
expected: nil
  actual: #object[Error Error: oops!]
nil

When I have a test that's calling into buggy code and an exception is thrown, I don't get the stack trace.

Compare this with clojure.test, which has more helpful output:

user> (require '[clojure.test :refer [deftest]])
nil
user> (deftest foo [] (throw (Exception. "Ooops!")))
#'user/foo
user> (foo)

ERROR in (foo) (NO_SOURCE_FILE:13)
Uncaught exception, not in assertion.
expected: nil
  actual: java.lang.Exception: Ooops!
 at user$fn__10841.invokeStatic (NO_SOURCE_FILE:13)
    user/fn (NO_SOURCE_FILE:13)
    clojure.test$test_var$fn__9894.invoke (test.clj:717)
    clojure.test$test_var.invokeStatic (test.clj:717)
    clojure.test$test_var.invoke (test.clj:708)
    user$foo.invokeStatic (NO_SOURCE_FILE:13)
    user$foo.invoke (NO_SOURCE_FILE:13)
    user$eval10844.invokeStatic (NO_SOURCE_FILE:15)
    user$eval10844.invoke (NO_SOURCE_FILE:15)
    clojure.lang.Compiler.eval (Compiler.java:7700)
    nrepl.middleware.interruptible_eval$evaluator$run__1435$fn__1446.invoke (interruptible_eval.clj:106)
    nrepl.middleware.interruptible_eval$evaluator$run__1435.invoke (interruptible_eval.clj:101)
    nrepl.middleware.session$session_exec$session_loop__1519.invoke (session.clj:230)
    nrepl.SessionThread.run (SessionThread.java:21)
nil

Maybe cljs.test could be improved to also include this useful information. I believe it would help with repl test/debugging workflows.

Thanks so much for your time and consideration.

Edit:

Eugene makes an interesting point in the comments.

There is a similar difference in exception/error printing:

In cljs:

harold@straylight:~/src/cljs-test-exception$ clj -M --main cljs.main --repl
ClojureScript 1.11.132
cljs.user=> (ex-info "hi" {})
#error {:message "hi", :data {}}
cljs.user=>

In clj:

user> (ex-info "hi" {})
#error {
 :cause "hi"
 :data {}
 :via
 [{:type clojure.lang.ExceptionInfo
   :message "hi"
   :data {}
   :at [user$eval8563 invokeStatic "NO_SOURCE_FILE" 11]}]
 :trace
 [[user$eval8563 invokeStatic "NO_SOURCE_FILE" 11]
  [user$eval8563 invoke "NO_SOURCE_FILE" 11]
  [clojure.lang.Compiler eval "Compiler.java" 7700]
  [nrepl.middleware.interruptible_eval$evaluator$run__1435$fn__1446 invoke "interruptible_eval.clj" 106]
  [nrepl.middleware.interruptible_eval$evaluator$run__1435 invoke "interruptible_eval.clj" 101]
  [nrepl.middleware.session$session_exec$session_loop__1519 invoke "session.clj" 230]
  [nrepl.SessionThread run "SessionThread.java" 21]]}

However, in the testing case, clojure.test explicitly prints the stack trace:

https://github.com/clojure/clojure/blob/fb22fd778a272b034684a4ee94509552b46ee8a9/src/clj/clojure/test.clj#L394

While cljs does not:

https://github.com/clojure/clojurescript/blob/d701b452b3f0b09f13191094bff9d5763a449191/src/main/cljs/cljs/test.cljs#L338-L344

It does still seem like the Error object is being swallowed, I don't see a way to gain access to it after running the test that threw.

Can custom literal collections reach parity with clojure's built in collections?

Thu, 20 Mar 2025 21:46:42 +0000

Teaching Old `eval` New Tricks

Tagged Literals Promise Extensibility

EDN and Tagged Literals:
- In EDN, tagged literals deliver complete extensibility.
- When processing EDN data, custom types created with tagged readers achieve parity with built-in literals.
Clojure’s Syntax and Tagged Literals:
- Clojure's syntax, as a superset of EDN, includes tagged literals.
- Key Differences:
- EDN is for reading data, while Clojure's syntax is expected to be eval'ed.
- Tagged literals in Clojure code are treated as second-class citizens compared to built-in types because:
```
1. The compiler inherently knows how to compile built-in types,
   but it does not understand other types returned by tagged
   readers.
```
Compiler Behavior and Challenges:
- By default:
- The compiler embeds the instance as a string in the emitted bytecode, recreating the instance at runtime via the reader.
- Issues with Collections:
- Container types like third party collections are problematic because their interior data is not evaluated.
- Common advice suggests returning a form that, when evaluated, creates an instance of the type. However:
```
- This makes the result no longer a literal, as:
  - The reader does not produce the expected type.
  - Macros don't see the expected type
  - You only get the expected type after eval.
- For mixed environments (EDN without eval vs. Clojure with
  eval), separate tagged readers for the same tag may be
  required.
```

Towards a Solution

Compiler Extensions:
- A potential solution involves creating an extension point to teach the compiler how to compile new types.
- Special care is required for cross-compiling dialects, such as ClojureScript.
- JVM collections might need to self-compile for ClojureScript.
Backward Compatibility:
- Ideally, any solution would:
- Retain the existing "self-quoting" behavior.
- Allow types to opt into new functionality.

core.async go block error with clojure 1.12 method values

Tue, 25 Feb 2025 19:17:23 +0000

I haven't seen this reported.

(Long/.toString 123) ;;works
(a/<!! (a/thread (Long/.toString 123))) ;;works
(a/go (Long/.toString 123)) ;;error

Note: The following stack trace applies to the reader or compiler, your code was not executed.

CompilerException Syntax error macroexpanding a/go at (1:1). {:clojure.error/phase :macro-syntax-check, :clojure.error/line 1, :clojure.error/column 1, :clojure.error/source "NO_SOURCE_PATH", :clojure.error/symbol a/go}
ExceptionInfo No matching method: .toString for class: class java.lang.Long and arity: 1 {:method .toString, :class java.lang.Long, :argc 1, :file "NO_SOURCE_PATH", :column 7, :line 1}
	clojure.tools.analyzer.passes.jvm.validate/validate-call (validate.clj:127)
	clojure.tools.analyzer.passes.jvm.validate/validate-call (validate.clj:87)
	clojure.tools.analyzer.passes.jvm.validate/eval4802/fn--4803 (validate.clj:137)
	clojure.lang.MultiFn.invoke (MultiFn.java:229)
	clojure.tools.analyzer.passes.jvm.validate/validate (validate.clj:265)
	clojure.tools.analyzer.passes.jvm.validate/validate (validate.clj:240)
	clojure.lang.Var.invoke (Var.java:386)
	clojure.tools.analyzer.passes/compile-passes/fn--3424/fn--3429 (passes.clj:167)
	clojure.tools.analyzer.passes/compile-passes/fn--3424/fn--3431 (passes.clj:169)
	clojure.tools.analyzer.passes/compile-passes/fn--3424/fn--3431 (passes.clj:169)
	clojure.tools.analyzer.passes/compile-passes/fn--3424/fn--3431 (passes.clj:169)
	clojure.core/partial/fn--5929 (core.clj:2648)

unable to use add-lib on io.github.borkdude/grasp

Fri, 17 Jan 2025 14:15:15 +0000

repro:

user=> (add-lib 'io.github.borkdude/grasp {:mvn/version "0.1.4"})
Execution error (ExceptionInfo) at clojure.tools.deps.interop/invoke-tool (interop.clj:81).
Could not find artifact org.clojure:clojure:jar:1.11.0-rc1

This seems strange to me. The deps edn of grasp: https://github.com/borkdude/grasp/blob/master/deps.edn

{:deps {org.babashka/sci {:mvn/version "0.3.2"}}
 :aliases {:native {:jvm-opts ["-Dclojure.compiler.direct-linking=true"]
                    :extra-deps {org.clojure/clojure {:mvn/version "1.10.2-alpha3"}
                                 org.clojure/tools.cli {:mvn/version "1.0.194"}}}
           :test {:extra-paths ["test"]
                  :extra-deps {org.clojure/clojure {:mvn/version "1.11.0-rc1"}
                               cognitect-labs/test-runner
                               {:git/url "https://github.com/cognitect-labs/test-runner"
                                :sha "cb96e80f6f3d3b307c59cbeb49bb0dcb3a2a780b"}}
                  :main-opts ["-m" "cognitect.test-runner"]}}}

It's surprising to me that deps in the :test alias would cause issues.

EDIT: seems to work now. Here's the stacktrace from a socket repl where i first encountered it

user=> (add-lib 'io.github.borkdude/grasp {:mvn/version "0.1.4"})
Execution error (ExceptionInfo) at clojure.tools.deps.interop/invoke-tool (interop.clj:81).
Could not find artifact org.clojure:clojure:jar:1.11.0-rc1
user=> nil
user=> (pst)
ExceptionInfo Could not find artifact org.clojure:clojure:jar:1.11.0-rc1 {:via [{:type clojure.lang.ExceptionInfo, :message "Could not find artifact org.clojure:clojure:jar:1.11.0-rc1", :data {:lib org.clojure/clojure, :coord {:mvn/version "1.11.0-rc1", :deps/manifest :mvn, :dependents [io.github.borkdude/grasp], :parents #{[io.github.borkdude/grasp]}}}, :at [clojure.tools.deps.extensions.maven$get_artifact invokeStatic "maven.clj" 167]}], :trace [[clojure.tools.deps.extensions.maven$get_artifact invokeStatic "maven.clj" 167] [clojure.tools.deps.extensions.maven$get_artifact invoke "maven.clj" 155] [clojure.tools.deps.extensions.maven$eval1225$fn__1228 invoke "maven.clj" 178] [clojure.lang.MultiFn invoke "MultiFn.java" 244] [clojure.tools.deps$download_libs$fn__802$fn__803 invoke "deps.clj" 466] [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] [clojure.lang.AFn applyToHelper "AFn.java" 156] [clojure.lang.RestFn applyTo "RestFn.java" 135] [clojure.core$apply invokeStatic "core.clj" 671] [clojure.core$bound_fn_STAR_$fn__5837 doInvoke "core.clj" 2020] [clojure.lang.RestFn invoke "RestFn.java" 400] [clojure.lang.AFn call "AFn.java" 18] [java.util.concurrent.FutureTask run "FutureTask.java" 317] [java.util.concurrent.ThreadPoolExecutor runWorker "ThreadPoolExecutor.java" 1144] [java.util.concurrent.ThreadPoolExecutor$Worker run "ThreadPoolExecutor.java" 642] [java.lang.Thread run "Thread.java" 1583]], :cause "Could not find artifact org.clojure:clojure:jar:1.11.0-rc1", :data {:lib org.clojure/clojure, :coord {:mvn/version "1.11.0-rc1", :deps/manifest :mvn, :dependents [io.github.borkdude/grasp], :parents #{[io.github.borkdude/grasp]}}}}
	clojure.tools.deps.interop/invoke-tool (interop.clj:81)
	clojure.tools.deps.interop/invoke-tool (interop.clj:41)
	clojure.repl.deps/add-libs (deps.clj:48)
	clojure.repl.deps/add-lib (deps.clj:59)
	clojure.repl.deps/add-lib (deps.clj:59)
	user/eval310956 (NO_SOURCE_FILE:320)
	user/eval310956 (NO_SOURCE_FILE:320)
	clojure.lang.Compiler.eval (Compiler.java:7700)
	clojure.lang.Compiler.eval (Compiler.java:7655)
	clojure.core/eval (core.clj:3232)
	clojure.core/eval (core.clj:3228)
	user/eval257807/fn--257810 (NO_SOURCE_FILE:8)

Is there a polished version of auto-agents?

Thu, 26 Dec 2024 18:41:21 +0000

I was reading Clojure in Action and thinking about agents. It seems that by hooking up agents with watches, update functions, and some simple locks, you could create a “reactive" state management. So that when some value a is updated then all dependent state values update themselves automatically and in parallel on separate threads. While those values are updating you are free to change other state values that aren't in the same dependency graph

I wrote up a quick draft but then started to look around online (it felt like a bit too obvious of an extension to the agent model). I found some similar ideas back in ~2009 but the trail goes dry. Is there some reason this isn't used more widely? Or is this some modern library I'm missing?

There was a "cell" implementation by Stuart Sierra called auto-agents - though I can't find the code

https://groups.google.com/g/clojure/c/NY834N34QvA

I also found this complete implementation but it's also got no traction at all

https://github.com/apatil/lazy-agent

Has this crystallized into a library somewhere? I'm thinking of writing my own implementation but I wanted a sanity check. I'm concerned maybe this idea was dropped for some reasons I've not considered

(I'm aware there are things like Javelin, Odoyle and Missionary that can accomplish similar things.. but while they decouple code, they're way too complicated and some don't have a threading story)

This is a copy of my question on Reddit:
https://reddit.com/comments/1hklfyh/comment/m3gyyoq

Incorrect result when evaluating `not=` on `##NaNs`

Sun, 08 Dec 2024 21:14:02 +0000

Alex Miller asked me to write this up here. I found a bug in clojure.core yesterday that involves not= when used to compare NaNs. This was reported on Slack and the discussion is here:
https://clojurians.slack.com/archives/C03S1KBA2/p1733612992809069

Here is a more highly summarized version of the discussion from Slack (at least from my perspective). If we fire up the Clojure CLI, we can evaluate the following.

 Clojure 1.12.0
 user=> (= ##NaN ##NaN)
 false
 user=> (not= ##NaN ##NaN)
 false
 user=> (not (= ##NaN ##NaN))
 true

The problem here is that =, not, and not= have a relationship between them. Specifically, for any x and y, if (= x y) returns a boolean, then (not (= x y)) should return the opposite boolean, and since not= is defined as (not (= x y)), it should return the same value as (not (= x y)) for all x and y. This doesn't happen if x and y are both ##NaN.

Note that there were a lot of calories burned on Slack with suggestions that doubles should never be compared for equality, that NaNs are shifty, not-quite-value objects and should be avoided, that anybody who wants to test for the presence of a NaN should use NaN? which is already in clojure.core, and that the documentation around equality should be updated to say some of those things. Many of those statements are true or good practice. But all of them miss the broader point.

This bug has nothing to do specifically to do with NaNs. It just seems that NaNs expose the bug. The real issue is with the contractual relationship between =, not, and not= which appears to be violated in the presence of NaNs. Specifically, not= is no longer referentially transparent with respect to (not (= ...)).

On Slack, @potetm decompiled the code generated for these cases and found the following.

For (not= ##NaN ##NaN) :

(clj-java-decompiler.core/decompile
  (not= ##NaN ##NaN))

// Decompiling class: cjd__init
import clojure.lang.*;

public class cjd__init
{
    public static final Var __not_EQ_;
    public static final Object const__1;
    
    public static void load() {
        ((IFn)cjd__init.__not_EQ_.getRawRoot()).invoke(cjd__init.const__1, cjd__init.const__1);
    }
    
    public static void __init0() {
        __not_EQ_ = RT.var("clojure.core", "not=");
        const__1 = Double.NaN;
    }
    
    static {
        __init0();
        Compiler.pushNSandLoader(RT.classForName("cjd__init").getClassLoader());
        try {
            load();
            Var.popThreadBindings();
        }
        finally {
            Var.popThreadBindings();
        }
    }
}

And then for (not (= ##NaN ##NaN)):

(clj-java-decompiler.core/decompile
  (not (= ##NaN ##NaN)))

// Decompiling class: cjd__init
import clojure.lang.*;

public class cjd__init
{
    public static final Var __not;
    
    public static void load() {
        ((IFn)cjd__init.__not.getRawRoot()).invoke(Util.equiv(Double.NaN, Double.NaN) ? Boolean.TRUE : Boolean.FALSE);
    }
    
    public static void __init0() {
        __not = RT.var("clojure.core", "not");
    }
    
    static {
        __init0();
        Compiler.pushNSandLoader(RT.classForName("cjd__init").getClassLoader());
        try {
            load();
            Var.popThreadBindings();
        }
        finally {
            Var.popThreadBindings();
        }
    }
}

It appears that the compiler optimizes the call to = and does not box the ##NaN values when compiling (not (= ##NaN ##NaN)), whereas the call to not= receives the ##NaNs boxed as Doubles. This then causes a subsequent call to clojure.lang.Util/equiv (after following the call chain through not= -> = -> clojure.lang.Util/equiv) to return true improperly (since NaNs are never equal to anything, even themselves).

IMO, this is a bug, albeit a low priority one. Most programmers successfully use floating point math without ever having to deal with NaNs. While NaNs seem to trigger the bug, there may be other cases that also trigger it. I can't speak to that.

CLR behavior of tools.namespace does not match the JVM implementation

Thu, 05 Dec 2024 14:44:05 +0000

I noticed a few behavioral differences between the CLR and JVM implementations of tools.namespace.

As an example, the following tests will pass in the JVM implementation and fail in the CLR implementation. In CLR, files-2 is empty and ::dir/time is an instant.

(ns clojure.tools.namespace.repl-test
  (:require [clojure.test :refer [deftest is]]
            [clojure.tools.namespace.dir :as dir]
            [clojure.tools.namespace.find :as find]
            [clojure.tools.namespace.repl :as repl]
            [clojure.tools.namespace.test-helpers :as help]))

(deftest t-repl-scan
  (let [dir        (help/create-temp-dir "t-repl-scan")
        _main-clj  (help/create-source dir 'example.main :clj '[example.one])
        _one-cljc  (help/create-source dir 'example.one :clj)
        _other-dir (help/create-temp-dir "t-repl-scan-other")
        files-1    (::dir/files (repl/scan {:platform find/clj}))
        files-2    (::dir/files (repl/scan {:platform find/clj}))]
    (is (not-empty files-1))
    (is (not-empty files-2))
    (is (= files-1 files-2))))

(deftest t-repl-scan-time
  (let [scan (repl/scan {:platform find/clj})]
    (is (integer? (::dir/time scan)))))

After discussing with other contributors, the question of intent came up and this test was proposed as something that correctly captures the intent of repl/scan. However, if this is the intended behavior, then a new problem arises as this test fails in the JVM implementation.

(deftest t-repl-scan
  (try
    (let [dir       (help/create-temp-dir "t-repl-scan")
          _main-clj (help/create-source dir 'example.main :clj '[example.one])
          _one-cljc (help/create-source dir 'example.one :clj)
          other-dir (help/create-temp-dir "t-repl-scan-other")
          _         (repl/set-refresh-dirs dir other-dir)
          scan1     (repl/scan {:platform find/clj})
          scan2     (repl/scan {:platform find/clj})
          files-1   (::dir/files scan1)
          files-2   (::dir/files scan2)]
      (is (= (count files-1) 2))
      (is (= (count files-2) 0)))
    (finally (repl/clear))))

A couple things I think would help here:
1. Flesh out the tools.namespace (JVM) test suite to capture all the intended behavior.
2. Realign clr.tools.namespace with tools.namespace.

Point 1 will provide a good baseline for point 2, as well as any other existing/future ports of tools.namespace and help prevent things from diverging in the future as changes are made.

Note

As of writing, repl/scan will throw an InvalidCastException on CLR. To fix this, replace clojure.tools.namespace.dir/modified-files with this:

(defn- modified-files [tracker files]
  (filter #(DateTime/op_LessThan ^DateTime (::time tracker System.DateTime/UnixEpoch) (.get_LastWriteTimeUtc ^FileSystemInfo %)) files))

Porting .NET 4.8 application using Clojure CLR to .NET 8

Sat, 12 Oct 2024 15:55:56 +0000

I am porting a C# application (AutoCAD plugin to be exact) from .NET 4.8 to .NET 8.

The code uses some Clojure CLR.
In .NET 4.8 the clojure namespaces were compiled to assemblies (.dll files) using Clojure.Compile.
At runtime, these namespaces were then loaded using clojure.lang.RT.load

However, precompiling clojure clr code is not possible in .NET 8. (https://ask.clojure.org/index.php/13866/is-still-possible-compile-cljr-files-dll-exe-dotent-and-above)

If I understood correctly, the recommended approach is to include the clojure sources with the application and then load the clojure namespaces using clojure.clr.api.Clojure class?
I could not find any examples or documentation on how to set up my application / environment so that clojure.core/load will find my .clj files.

On page
https://github.com/clojure/clojure-clr/wiki/Using-ClojureCLR-in-a-C#-project
there is instructions on how to invoke clojure.core/load

IFn load= clojure.clr.api.Clojure.var("clojure.core", "load");
load.invoke("some.thing");

However, clojure.core/load is documented to use CLASSPATH to find namespaces. Does this also apply in Cojure CLR, i.e. should I define an appropriate CLASSPATH environment variable before calling clojure.core/load ?
https://clojuredocs.org/clojure.core/load

Memory leak in seque via agents

Thu, 10 Oct 2024 23:03:20 +0000

We used seque to manage a large database migration and observed a possible memory leak that required us to restart it several times.

We iterated through hundreds of queries to extract data via reduce, each using its own seque but eventually ran out of memory.

I believe it could have been related to seque and its use of agents, which was predicted to leak memory in CLJ-1125. We have not since tried a migration without seque for comparison, but I instead turned my attention to seque and found possibly-related problems.

seque uses an agent to offer items to its buffer. Agents have a memory leak where the conveyed bindings of a send are held by the executing Thread (the most relevant being *agent*). This means even if the seque is gc'ed, the agent persists if the thread is part of a cached thread pool, usually containing realized items from the producing seq (such as the first item to fail to be offered to the buffer).

I believe this demonstrates seque leaking memory (Clojure 1.12.0):

(let [pool-size 500]
  (defn expand-thread-pool! []
    (let [p (promise)]
      (mapv deref (mapv #(future (if (= (dec pool-size) %) (deliver p true) @p)) (range pool-size))))))

(let [_ (expand-thread-pool!) ;; increases likelihood of observing leak
      ready (promise)
      strong-ref (volatile! (Object.))
      weak-ref (java.lang.ref.WeakReference. @strong-ref)
      the-seque (volatile! (seque 1 (lazy-seq
                                      (let [s (repeat @strong-ref)]
                                        (deliver ready true)
                                        s))))]
  @ready
  (vreset! strong-ref nil)
  (vreset! the-seque nil)
  (System/gc)
  (doseq [i (range 10)
          :while (some? (.get weak-ref))]
    (prn "waiting for gc...")
    (Thread/sleep 1000)
    (System/gc))
  (prn (if (nil? (.get weak-ref))
         "garbage collection successful"
         "seque memory leak!!")))
;"waiting for gc..."
;"waiting for gc..."
;"waiting for gc..."
;"waiting for gc..."
;"waiting for gc..."
;"waiting for gc..."
;"waiting for gc..."
;"waiting for gc..."
;"waiting for gc..."
;"waiting for gc..."
;"seque memory leak!!"

This can be reproduced with agents. Once an agent has executed an action, a strong reference persists to the agent via *agent* in the cached thread it was executed in. Here we observe the agent is not garbage collected if it has executed an action on a cached thread pool (Clojure 1.12.0):

(let [_ (expand-thread-pool!)
      strong-ref (volatile! (agent nil))
      weak-ref (java.lang.ref.WeakReference. @strong-ref)]
  ;#_#_ ;;uncomment this and the agent is freed
  (send-off @strong-ref vector)
  (doseq [i (range 10)
          :while (not (vector? @@strong-ref))]
    (Thread/sleep 1000))
  (vreset! strong-ref nil)
  (System/gc)
  (doseq [i (range 10)
          :while (some? (.get weak-ref))]
    (prn "waiting for gc...")
    (Thread/sleep 1000)
    (System/gc))
  (prn (if (nil? (.get weak-ref))
         "garbage collection successful"
         "agent memory leak!!")))
;"waiting for gc..."
;"waiting for gc..."
;"waiting for gc..."
;"waiting for gc..."
;"waiting for gc..."
;"waiting for gc..."
;"waiting for gc..."
;"waiting for gc..."
;"waiting for gc..."
;"waiting for gc..."
;"agent memory leak!!"

clojure.data.priority-map's IKVReduce implementation doesn’t support `reduced`

Sat, 28 Sep 2024 23:52:55 +0000

Hi folks!

Just a heads-up that clojure.data.priority-map’s IKVReduce implementation doesn’t support reduced.

The current implementation (v1.2.0, 2024-02-19):

clojure.core.protocols/IKVReduce
(kv-reduce [this f init]
  (if keyfn            
    (reduce-kv (fn [a k v] (reduce (fn [a v] (f a v (item->priority v))) a v))
      init priority->set-of-items)
    (reduce-kv (fn [a k v] (reduce (fn [a v] (f a v k)) a v))
      init priority->set-of-items)))

But the nested reduce means that something like this’d be needed:

(defn- convey-reduced [x] (if (reduced? x) (reduced x) x))

clojure.core.protocols/IKVReduce
(kv-reduce [this f init]
  (if keyfn            
    (reduce-kv (fn [a k v] (reduce (fn [a v] (convey-reduced (f a v (item->priority v))) a v)))
      init priority->set-of-items)
    (reduce-kv (fn [a k v] (reduce (fn [a v] (convey-reduced (f a v k)) a v)))
      init priority->set-of-items)))

Note that the issue affects only (reduce-kv a-priority-map …), not (reduce a-priority-map …).

Thanks, cheers! :-)

Suggested improvements to clojure.core/distinct

Sat, 28 Sep 2024 09:43:58 +0000

After looking at some performance improvements around clojure.core/distinct, I discovered that Nikita (@tonsky) had made suggestions about this back at the end of 2016, along with a code submission at CLJ-2090.

At the time, Alex made a comment about waiting until clojure.core/contains? supported transient sets, and the issue was pushed back. I note that this has now been addressed. However, in trying a few different approaches, I actually get better performance not using a transient at all, but instead checking if a conj has modified the object. This is done using a non-atomic deref/vreset, which begs the questions… is accessing a transducer supposed to be considered thread-safe? There are approaches to mitigate this, but there isn't a need if that's not a guarantee.

I discuss some of the approaches and provide some benchmarking in this project on Github. The fastest approach actually uses the ITransientSet interface directly, which I got the impression Alex would like to avoid.

Stack overflow with lazy-seq

Sun, 02 Jun 2024 19:14:33 +0000

I'm learning Clojure by doing problems from rich4clojure repo. Problem 147 asks one to create a function which returns a lazy sequence of rows following rules of Pascal triangle given initial row. For example, for [3 1 2], the next row is [3 4 3 2]. Here's my solution:

(defn pascal
      ([row] (lazy-seq (cons row (__ row :next))))
      ([row _]
       (lazy-seq
        (let [next-row (map #(apply +' %) (partition 2 1 (concat '(0) row '(0))))]
          (cons next-row (pascal next-row :next)))))))

I decided to test it and compare it with solutions others came up with. For example, one user wrote:

(defn pascal [coll]
(lazy-seq
  (cons coll
        (pascal (let [middle (map #(apply +' %) (partition 2 1 coll))]
                       (concat [(first coll)] middle [(last coll)]))))))

I time both solutions by evaluating:

time (nth (nth (pascal [1]) 400) 50))

and it turns out that mine is faster (which is sort of expected because the other user relies on last which is O(n)). However, when I try to calculate 1000th row, I get stack overflow error only in case of my function. I'm struggling to see why this happens because I shouldn't be increasing the stack size. What am I missing?

Cannot invoke "clojure.lang.Var.isBound()" because "clojure.lang.Compiler.LOADER" is null, potential bug?

Thu, 18 Apr 2024 16:11:35 +0000

As per discussion on slack I'm posting here the findings regarding clojure.lang.Compiler.LOADER being null during the analysis phase of GraalVM native-image run.

The full reproduction can be found here and the link to issue on Oracle GraalVM side here.

What is this issue about?

Native Image cannot be produced and throws an error during analysis phase when Clojure 1.11.2 (although the previous version of Clojure might be also affected) is used and reflection entries for java.lang.UUID and clojure.lang.Keyword are present in reflectionconfig.json.

I can't however reproduce the error prior to Clojure 1.9.0. For more information please kindly take a look into a repro.

How to load couple of modules with cljs.loader/load?

Sat, 06 Apr 2024 08:19:03 +0000

I didn't expect any problems with the task initially. Just loaded them one by one with cljs.loader/load until....
Until I got 'beforeLoadModuleCode called with module module2 while module module1 is loading'
First I realized that load was asynchronous and module loading wasn't actually finished when load exited. Digging goog.module.ModuleManager left me with an impression that its load() function is capable to queue new module loading until the previous one finishes loading.

My impression that the problem is that cljs.loader/load calls beforeLoadModuleCode() at the wrong moment of time. It seems that it must be called at the very begining of evaluating the module code, not before it even starts to download it as it is now, i.e., setLoaded is the last instruction of the module and beforeLoadModuleCode must be the first.
However, I'm still unsure I'm getting the whole idea behind ModuleManager correctly so I need a confirmation that I'm correct.

Clojurescript unable to use arrow constructors in body of defrecord, while Clojure does

Sat, 16 Mar 2024 08:14:12 +0000

I get a warning if I try to compile a defrecord where a method tries to call the arrow constructor.

This:

(defrecord Foo [a b]
  SomeProtocol
  (some-method [_]
    (->Foo new-a new-b)))

gives the message "WARNING: Use of undeclared Var some.ns/->Foo at line X". Clojure accepts this form ok.

If I switch to the dot constructor version, like (Foo. _ _) it compiles.

I noticed that in the clj defrecord macro, the symbols for ->Foo and map->Foo are declared first thing, but in cljs, the related build-positional-factory and build-map-factory fns are called at the end, after emit-defrecord. Perhaps that's the issue?

It looks like deftype should have a similar issue, but I haven't tested it.

Warn about user.clj during build compilation

Wed, 28 Feb 2024 13:20:46 +0000

We’ve had a few cases where people encountered issues due to the existence of user.clj during uberjar building with tools.build.

Because user loads early, anything it loads is not (typically) reloaded during compilation, which can lead to some namespaces not being compiled.

Should maybe warn if user is on classpath or even actively recompile with something like

(binding [*compile-files* true] (require 'user :reload-all))

Add `debug-assert` as a separate, off-by-default operation for expensive dev/test-only assertions

Tue, 06 Feb 2024 17:42:43 +0000

Currently the default value for clojure.core/*assert* is true.

This has some implications for library creators and consumers.

As a library creator you can't just add asserts everywhere to help you on dev/test because it will make most users pay the performance price in production, since they will be running with *asserts* enable.

As a library consumer, since you don't know what libraries are using asserts, you have to always remember to disable them just in case.

This is worsen by the fact that is not easy to disable them globally in Clojure, since assert is a macro that checks *assert*, the value of the var needs to be set before loading any namespace.

On the contrary java makes all assertions disable by default, so library creators don't have to think about this, and the consumers can explicitly enable them at dev time by providing java -ea (enable assertions)

Since I guess changing the default value of *assert* could be problematic because of backwards compatibility, it would maybe be possible to add a debug-assert like is the case of Rust, which will not be on by default.

As I see it, the important part is having a simple invariant checking instruction that we know is not going to impact performance by default, so hardening our code base for test and dev is not coupled to production performance in the default case.

Two other options are better default values for assert, one is false and the other is the value of java.lang.Class desiredAssertionStatus() which seams to return true/false depending on the -ea flag being provided or not, which will be also false by default., but since most Clojure users already rely on assert being true by default this are maybe not an option.

Incorrect deprecation warnings

Sun, 28 Jan 2024 16:39:42 +0000

Using this minimal project, I get deprecation warnings regarding unused library code:

deps.edn
`clojure

{:deps {org.clojure/clojurescript {:mvn/version "1.11.54"}
com.taoensso/timbre {:mvn/version "6.3.1"}
}}

src/hello_world/core.cljs
`clojure

(ns hello-world.core
  (:require [taoensso.timbre :as log]))

(log/info "Hello")
(println "Hello world!")

`
`clojure

yenda@project2503:~/test-warning$ clj -M -m cljs.main -c hello-world.core
WARNING: taoensso.encore/compile-ns-filter is deprecated at line 6125 /home/yenda/.cljs/.aot_cache/1.11.54/02F6365/taoensso/encore.cljc
WARNING: taoensso.encore/rate-limiter* is deprecated at line 6202 /home/yenda/.cljs/.aot_cache/1.11.54/02F6365/taoensso/encore.cljc
WARNING: taoensso.encore/rate-limiter* is deprecated at line 6209 /home/yenda/.cljs/.aot_cache/1.11.54/02F6365/taoensso/encore.cljc
WARNING: taoensso.encore/rate-limiter* is deprecated at line 6211 /home/yenda/.cljs/.aot_cache/1.11.54/02F6365/taoensso/encore.cljc
WARNING: taoensso.encore/distinctv is deprecated at line 6266 /home/yenda/.cljs/.aot_cache/1.11.54/02F6365/taoensso/encore.cljc
WARNING: taoensso.encore/-swap-val! is deprecated at line 6306 /home/yenda/.cljs/.aot_cache/1.11.54/02F6365/taoensso/encore.cljc
WARNING: taoensso.encore/sub-indexes is deprecated at line 6334 /home/yenda/.cljs/.aot_cache/1.11.54/02F6365/taoensso/encore.cljc
WARNING: taoensso.encore/sub-indexes is deprecated at line 6343 /home/yenda/.cljs/.aot_cache/1.11.54/02F6365/taoensso/encore.cljc
WARNING: taoensso.encore/sentinel? is deprecated at line 6349 /home/yenda/.cljs/.aot_cache/1.11.54/02F6365/taoensso/encore.cljc
WARNING: taoensso.encore/singleton? is deprecated at line 6352 /home/yenda/.cljs/.aot_cache/1.11.54/02F6365/taoensso/encore.cljc

"Unbound var" error with reader-macro + arglists + AoT

Fri, 12 Jan 2024 11:19:03 +0000

Hey Alex :)

Think this may be a compiler bug - necessary conditions seem to be:

Custom reader macro
Used in destructuring in defn
AoT compiled

e.g.

(ns foo
  (:require my.reader-macros))

(defn foo [{:keys [a], :or {a #my/reader-macro "..."}]
  ...)

In the class file, I get:

static {
    __init0();
    __init1();
    Compiler.pushNSandLoader(RT.classForName("foo__init").getClassLoader());

    try {
        load();
    } catch (Throwable var1) {
        Var.popThreadBindings();
        throw var1;
    }

    Var.popThreadBindings();
}

load() calls new foo.loading__9166().invoke(), which applies the :requires
but, in the __init1() (in my case) it tries to create the vars, including applying the arglists metadata. In applying that metadata, it has:
```
    RT.keyword((String)null, "or"), 
    RT.map(new Object[]{Symbol.intern((String)null, "a"), RT.readString("#my/reader-macro \"...\"")})
```
and the RT.readString call fails with 'unbound var' because my.reader-macros hasn't been required yet.

Work-around is easy enough, and I daresay it's relatively rare given removing any of the three conditions above fixes the issue, but thought I'd raise nonetheless :)

Cheers,

James

Executable 'java' not found on system path.

Wed, 03 Jan 2024 19:38:51 +0000

Hi guys I,m basically trying to run a clojure script app using a shadow file, to be honest i don't really know too much about clojure since this is a project that i downloaded, but i need it to make it run locally on windows 11 and i'm receiving the following error

shadow-cljs - config: C:\Appsmiths\i\src\winglue\webglue\shadow-cljs.edn
===== ERROR =================

Executable 'java' not found on system path.

I have java on my system of course and my environment variables are well configured, so i think it could be something inside of the shadow file, but i cannot identify what it is, if you can help me out with this it would be really helpful

this is basically all the shadow config:

;; shadow-cljs configuration
{:dependencies [
                [akiroz.re-frame/storage "0.1.3"]
                [bidi "2.1.5"]
                [com.cemerick/url "0.1.1"]
                [binaryage/devtools "1.0.2"]
                [binaryage/oops "0.7.1"]
                [com.cognitect/transit-cljs "0.8.256"]
                [com.rpl/specter "1.1.3"]
                [com.taoensso/timbre "4.10.0"]
                [cljs-http "0.1.46"]
                [day8.re-frame/async-flow-fx "0.1.0"]
                [day8.re-frame/http-fx "0.1.6"]
                [day8.re-frame/re-frame-10x "1.5.0"]
                [day8.re-frame/tracing "0.5.1"]
                [day8.re-frame/undo "0.3.2"]
                [district0x/graphql-query "1.0.6"]
                [district0x/re-frame-interval-fx "1.0.2"]
                [expound "0.8.5"]
                [funcool/cuerdas "2021.05.29-0"]
                [funcool/promesa "2.0.1"]
                [juji/editscript "0.4.6"]
                [maximgb/re-state "1.5.0"]
                [medley "1.2.0"]
                [metosin/spec-tools "0.10.4"]
                [org.clojure/data.json "0.2.6"]
                [org.clojure/spec.alpha "0.2.187"]
                [pez/clerk "1.0.0"]
                [prismatic/schema "1.1.12"]
                [re-frame "1.3.0"]
                [re-graph "0.1.15" :exclusions [cljs-http]]
                [com.andrewmcveigh/cljs-time "0.5.2"]
                [reagent "1.1.1"]
                [spyscope "0.1.6"]
                [venantius/accountant "0.2.5"]
                [lambdaisland/regal "0.0.143"]
                [cheshire "5.11.0"]
                [camel-snake-kebab "0.4.3"]
                [garden/garden-units "1.0.0-RC2"]
                [cljs-bean "1.8.0"]]

 :source-paths ["lib" "graphql" "src" "C:/Appsmiths/i/src/winglue-artifact/webglue" "test"]
 :nrepl {:port 41002}
 :open-file-command ["idea " :pwd " --line " :line :file]
 ;; webglue artifact are in /i/src/winglue-artifact/webglue/js
 :builds {:app {:output-dir "C:/Appsmiths/i/src/winglue-artifact/webglue/js"
                :asset-path "/js"
                :compiler-options
                {:optimizations :none
                 ;; use es2018 for recat-markdown-editor
                 :output-feature-set :es2018
                 :main webglue.core
                 :closure-warnings {:global-this :off}
                 :closure-defines {re-frame.trace/trace-enabled? true
                                   day8.re-frame-10x.debug?             true
                                   day8.re-frame.tracing.trace-enabled? true}
                 :external-config {:devtools/config {:features-to-install    [:formatters :hints]
                                                     :fn-symbol              "Fn"
                                                     :print-config-overrides true}}}
                :target :browser
                :js-options {:ignore-asset-requires true}
                :module-loader true
                :modules {:webglue
                          {:entries [webglue.core]}
                          :ag-grid
                          {:entries [webglue.components.ag-grid]
                           :depends-on #{:webglue}}
                          :dev
                          {:entries [webglue.pages.component-show-case webglue.pages.dev]
                           :depends-on #{:webglue}}
                          :plot
                          {:entries [webglue.component-generator.graph
                                     webglue.component-generator.ivsp-plot
                                     webglue.component-generator.pie-chart
                                     webglue.component-generator.bar-chart
                                     webglue.component-generator.bubble-chart]
                           :depends-on #{:webglue}}}
                :devtools {:repl-pprint true
                           :after-load webglue.core/reload!
                           :loader-mode :eval
                           :http-root "C:/Appsmiths/i/src/winglue-artifact/webglue"
                           :http-port 3333
                           :http-handler shadow.http.push-state/handle
                           :preloads [devtools.preload
                                      ; use only for debug re-frame, this option wil take 300 ms to reload and 330 file to watch
                                      ; run by uncomment next line, and save. shadow-cljs will do the rest
                                      day8.re-frame-10x.preload]}}
          :win-app {:output-dir "C:/Appsmiths/i/src/winglue-artifact/webglue"
                    :asset-path "/js"
                    :compiler-options
                    {:optimizations :none
                     :output-feature-set :es2018
                     :main webglue.core
                     :closure-warnings {:global-this :off}
                     :closure-defines {re-frame.trace/trace-enabled? true
                                       day8.re-frame-10x.debug?             true
                                       day8.re-frame.tracing.trace-enabled? true}
                     :external-config {:devtools/config {:features-to-install    [:formatters :hints]
                                                         :fn-symbol              "Fn"
                                                         :print-config-overrides true}}}
                    :target :browser
                    :js-options {:ignore-asset-requires true}
                    :modules {:webglue {:entries [webglue.core]}}
                    :devtools {:http-port 3434
                               :http-root "C:/Appsmiths/i/src/winglue-artifact/webglue"
                               :http-handler shadow.http.push-state/handle
                               :after-load webglue.core/reload!
                               :loader-mode :eval
                               :preloads [devtools.preload
                                          day8.re-frame-10x.preload]}}
          :test {:target :browser-test
                 :test-dir "test-assets"
                 :devtools {:http-port 9100
                            :http-root "test-assets"}
                 :runner-ns main-test-initial
                 :js-options {:ignore-asset-requires true}
                 :ns-regexp "-test$"}

          :app-release {:target :browser
                        :modules {:webglue
                                  {:entries [webglue.core]}}
                        :js-options {:ignore-asset-requires true}
                        :compiler-options {:source-map false
                                           :output-feature-set :es2018
                                           :main  webglue.core
                                           :closure-defines {}}
                        :release  {:output-dir "C:/Appsmiths/i/src/winglue-artifact/webglue/js"}}

          :tao2py-release {:target :browser
                           :js-options {:ignore-asset-requires true}
                           :compiler-options
                           {:source-map false
                            :output-feature-set :es2018
                            :main  webglue.core
                            :closure-defines {webglue.config/tao2py-release true
                                              ;; landing page is page key in webglue.route_pages
                                              webglue.config/landing-page "field-overview"}}
                           :release  {:output-dir "C:/Appsmiths/i/src/winglue-artifact/webglue/js"
                                      :asset-path "/js"}
                           :module-loader true
                           :modules {:webglue
                                     {:entries [webglue.core]}
                                     :ag-grid
                                     {:entries [webglue.components.ag-grid]
                                      :depends-on #{:webglue}}
                                     :dev
                                     {:entries [webglue.pages.component-show-case webglue.pages.dev]
                                      :depends-on #{:webglue}}
                                     :plot
                                     {:entries [webglue.component-generator.graph
                                                webglue.component-generator.ivsp-plot
                                                webglue.component-generator.pie-chart
                                                webglue.component-generator.bar-chart
                                                webglue.component-generator.bubble-chart]
                                      :depends-on #{:webglue}}}}

          :tao2py-testing {:target :browser
                           :modules {:webglue
                                     {:entries [webglue.core]}}
                           :js-options {:ignore-asset-requires true}
                           :compiler-options {:source-map false
                                              :output-feature-set :es2018
                                              :main  webglue.core
                                              :closure-defines {}}
                           :release  {:output-dir "C:/Appsmiths/i/src/winglue-artifact/webglue/js"}}

          :budger-release {:target :browser
                           :modules {:webglue {:entries [webglue.core]}}
                           :release {:output-dir "release/js"}
                           :js-options {:ignore-asset-requires true}
                           :compiler-options {:source-map false
                                              :output-feature-set :es2018
                                              :main       webglue.core
                                              :closure-defines {}}}}}

Hypergraphs, via protocols, perhaps extending loom?

Thu, 09 Nov 2023 02:41:39 +0000

I am exploring clojure implementations of hypergraphs (edges can join > 2 nodes)? i've used loom for graphs, and imagine trying to extend it somehow.

either with loom or without, any suggestions how to use PROTOCOLS for these definitions?

thanks for any suggestions. - RIk

Test suit doesn't find function implemented in my solution

Sun, 01 Oct 2023 14:05:15 +0000

I have submitted a solution to the bird watcher problem, and the test suit complains that it doesn't find the function day-without-birds. Visual Studio Code is able to import it and run it from another file.

The full implementation of the solution is as follows:

Solution

(ns bird-watcher)

 (def last-week [0 2 5 3 7 8 4])

 (defn last_position [v]
   (- (clojure.core/count v) 1))

 (defn today [birds]
   (get birds (last_position birds)))

(defn inc-bird [birds]
  (assoc birds (last_position birds)  (+ (today birds) 1)))

(defn day-without-birds
  [birds]
  (loop [y birds]
    (let [[x & rest] y]
      (if (= x 0)
        true
        (if (empty? rest)
          false
          (recur rest))))))
 
 

(defn n-days-count [birds n]
  (reduce + (take n birds)))

(defn busy [day]
  (if (> day 5)
    1
    0))

(defn busy-days [birds]
  (reduce + (map busy birds)))

(defn odd-week-internal
  [birds x]
  (loop [y birds
         target x]
    (let [[x & rest] y
          target (- 1 target)]
      (if (= x target)
        (if (empty? rest)
          true
          (recur rest target))
        false))))

(defn odd-week [birds]
  (odd-week-internal birds 0))

Thank you in advance!

print-method is inconsistent with regard to clojure.pprint with print-level

Thu, 28 Sep 2023 07:02:04 +0000

Repro:

;; print-method

user=> (binding [*print-level* 1]
         (prn {:a 1 :b 2}))
{:a 1, :b 2}
nil

user=> (binding [*print-level* 1]
         (prn {:a {:b 2}}))
{:a #}
nil

user=> (binding [*print-level* 1]
         (prn [(clojure.lang.MapEntry. :a 1)
               (clojure.lang.MapEntry. :b 2)]))
[# #]
nil

;; clojure.pprint

user=> (binding [*print-level* 1]
         (clojure.pprint/pprint {:a 1 :b 2}))
{#, #}
nil

user=> (binding [*print-level* 1]
         (clojure.pprint/pprint {:a {:b 2}}))
{#}
nil

user=> (binding [*print-level* 1]
         (clojure.pprint/pprint
           [(clojure.lang.MapEntry. :a 1)
            (clojure.lang.MapEntry. :b 1)]))
[# #]
nil

The docstring for *print-level* says:

If an object is a collection and is at a level greater than or equal to the value bound to print-level, the printer prints '#' to represent it.

A map entry is a collection and in {:a 1, :b 2} is at a level equal to *print-level*, so I would expect prn to have the same output as clojure.pprint.

Abstract env var reading in tools.deps

Sat, 16 Sep 2023 02:35:57 +0000

I have a Cursive user wanting to use the CLOJURE_CLI_ALLOW_HTTP_REPO env var. Since Cursive invokes tools.deps in-process, there's no way for me to set an env var in the current process. deps.clj has a nice abstraction for this - would it be possible to use this or something similar for tools.deps too? I assume this problem will affect any process using tools.deps as a library.

How to design testing library?

Fri, 15 Sep 2023 20:47:59 +0000

I would like to create a sort of testing library or framework. The main purpose of it is to run UI tests on Android device. For example, here is example of how I would like it look like:

(test-flow
    (launch-app "some.app.id")
    (assert-visible "Login")
    (type-text "admin")
    (tap-on "unlockButton")
    (assert-visible "HomeScreen"))

I hope this API looks nice and clear. Basically here is what it is supposed to do:
- launch application with id "some.app.id"
- check that login field with name "Login" is visible on the screen
- type a text "admin" (into login field)
- tap on unlock button
- check that text "HomeScreen" is visible, what means we successfully logged in.

I've already created all the desired functions above and that was easy part. I've designed them so they return a hash-map that may have either :result or :error. But I've been stuck on how to use those functions together, so it will work as a testing framework. If I put them inside some function and if some of the steps fails, then execution will just continue to the next step. Moreover, the result of a failed step will be lost. After that I decided to write a macros, that will transform all functions into list, evaluate them one by one and return detailed result for each step. But I failed to do that (event with the help of ChatGPT), maybe because I'm noob in Clojure.

After probably a week of inability to solve this problem, I think maybe I'm doing something wrong. Maybe someone could help me with that API problem?

Here is my vision of that API:
- the result of the test should have results from all executed steps (functions)
- if one step fails, then execution should be stopped, and results for all executed steps should be returned.

I was inspired by this framework, I just think it would be much easier to write such tests with REPL and do some Clojure magic inside the test :)

Thanks!

Clojure Q&A - Recent questions without answers

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

TypedArrays don't implement ICounted in cljs

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

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

Threading macro with update and when produces incorrect results

`pipeline-blocking` uses `thread` internally instead of `io-thread`

Choosing between core.async pipelines

Allocation churn on generators

`(s/gen ...)` caches its failure to load generators and thus is incompatible with `add-lib`

Possible ClojureScript bug: corner case with regex literal compilation

Improve javadoc especially for tool usage

clojure -X hangs with agent use

Porting clojure libraries w/ java interop to clojure-clr

select-keys on nil map

Compiler-generated `foo__init.class` files lack `SourceFile` attribute

Skip stacktrace creation in ExceptionInfo

How best to call long-running tasks from a core.async.flow process?

Metadata on quoted forms

POSIX-style command line arguments in tools (-T)

`create-basis` silently accepts missing aliases

Improve clojure cli error msg: "The following libs must be prepared" could include "clojure -X:deps prep"

`(even? (range))` hangs

Associative destructuring with if-let

regular expression with Classes for Unicode scripts, blocks, categories and binary properties

Does clojure-clr work on Android?

Is cljs.test swallowing exceptions?

Can custom literal collections reach parity with clojure's built in collections?

Teaching Old eval New Tricks

Tagged Literals Promise Extensibility

Towards a Solution

core.async go block error with clojure 1.12 method values

unable to use add-lib on io.github.borkdude/grasp

Is there a polished version of auto-agents?

Incorrect result when evaluating `not=` on `##NaNs`

CLR behavior of tools.namespace does not match the JVM implementation

Porting .NET 4.8 application using Clojure CLR to .NET 8

Memory leak in seque via agents

clojure.data.priority-map's IKVReduce implementation doesn’t support `reduced`

Suggested improvements to clojure.core/distinct

Stack overflow with lazy-seq

Cannot invoke "clojure.lang.Var.isBound()" because "clojure.lang.Compiler.LOADER" is null, potential bug?

How to load couple of modules with cljs.loader/load?

Clojurescript unable to use arrow constructors in body of defrecord, while Clojure does

Warn about user.clj during build compilation

Add `debug-assert` as a separate, off-by-default operation for expensive dev/test-only assertions

Incorrect deprecation warnings

"Unbound var" error with reader-macro + arglists + AoT

Executable 'java' not found on system path.

Executable 'java' not found on system path.

Hypergraphs, via protocols, perhaps extending loom?

Test suit doesn't find function implemented in my solution

print-method is inconsistent with regard to clojure.pprint with *print-level*

Abstract env var reading in tools.deps

How to design testing library?

Teaching Old `eval` New Tricks

print-method is inconsistent with regard to clojure.pprint with print-level