Clojure Q&A - Questions without answers in ClojureCLR

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

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

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.

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