Clojure Q&A - Recent questions tagged clojure.core

`eval` using functions with metadata

Mon, 01 Jun 2026 14:33:00 +0000

TIL:

(eval (list + 1 2)) ; works
(eval (list (var-get #'+) 1 2)) ; works
(eval (list (fn [a b] (+ a b)) 1 2)) ; works

(defmacro m [] `(~(fn [a b] (+ a b)) 1 2))
(m) ; also works

;; however, if the function has any metadata:
(eval (list (with-meta + {}) 1 2))
;; ^ fails, No matching ctor found for class clojure.lang.AFunction$1

This was unintuitive to discover.

I solved it locally with a little helper:

(defn val->expr [v]
  (if (symbol? v)
    `'~v
    (cond-> v
      (and (fn? v) (not (nil? (meta v))))
      (-> (with-meta nil)
          (list (-> v meta (update-vals val->expr)))
          (conj `with-meta)))))

But this takes special handling. I wonder if something similar would not be possible on a "matching ctor"-level, possibly also for comp, every-pred?, etc. It would be fairly trivial even in userland to have versions of these functions which carry metadata sufficient to recreate expressions, e.g. comp storing the list of functions, and then eval, on encountering No matching ctor found for class clojure.core$comp$fn__5921, can instead pull out the list of functions from that value and evaluate (list* comp (:composed-fns (meta v))) (or some such) instead.

I think this would be great to have in the core lib, at least for metadata and core libs functions like comp, some-fn, every-pred?, and complement.

Note, I'm not talking about adding or changing ctors for these necessarily. A hook for taking unconstructable values and making a constructable value out of them would serve just as well, maybe even a multifn.

Strictly in userland and without core lib support, I suppose the cleanest way to do something like this is a custom protocol and probably monkeypatch some core libs functions (maybe eval?)

So I suppose my questions are:

Is this something you agree would be good to have in general? Or is this by design for some reason I can't see?
Would this be good and practical to have in the corelib? Oughtn't be a breaking change at least
If no, is there currently any sane way to apply my solution in a more systemic way than wrapping every relevant value with a val->expr call?

Optimized str function

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

Opimized version of str function:

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

Benchmarks:

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

Evaluation count : 2577840 in 60 samples of 42964 calls.

         Execution time mean : 23.611394 µs

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

Evaluation count : 1375200 in 60 samples of 22920 calls.

         Execution time mean : 42.015320 µs

specifying `:let` as the first element of `for` causes an macro expansion error

Sun, 10 Aug 2025 02:40:33 +0000

We can use :let in for to define local variable like this

(for [i (range 5)
      :let [inc-i (inc i)]]
  [i inc-i])
;;=> ([0 1] [1 2] [2 3] [3 4] [4 5])

Otherwise, if we specified :let as first element, it causes an macro expansion error.

(for [:let [range-end 5]
      i (range range-end)
      :let [inc-i (inc i)]]
  [i inc-i])
;;=> Syntax error macroexpanding for at (*cider-scratch*:555:1).
;;   Can't pop empty vector

Of course, in this case, we should have wrapped for in let. However, I'm curious whether making :let available only for second and subsequent elements is intended behavior as part of the public interface.

Is RT.longCast() missing an overload for char?

Thu, 31 Jul 2025 11:02:56 +0000

This code resorts to reflection:

(long (char \x))

call to static method longCast on clojure.lang.RT can't be resolved (argument types: char).

Casting to int does not trigger this reflection warning, as RT.intCast(char) exists.

It seems to me there should be a RT.longCast(char) as well?

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

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

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

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

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

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

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

Thank you!

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.

Could we have a msg arg to time?

Wed, 22 Jan 2025 21:03:28 +0000

Very handy in CLJC projects especially to log long running operations. Happy to do PR(s).

  [expr msg]
  `(let [start# (. System (nanoTime))
         ret# ~expr]
     (prn (str msg (/ (double (- (. System (nanoTime)) start#)) 1000000.0) " msecs"))
     ret#))

Even better would be fmt-msg. (format msg-msg (/ (double (- (. System (nanoTime)) start#)) 1000000.0))

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.

Add index-by function to the clojure.core namespace

Thu, 11 Jan 2024 18:34:49 +0000

What do you think about adding the index-by function to the core namespace? It's like group-by but doesn't create a vector:

(defn index-by
  "Return a map where a key is (f item) and a value is item."
  {:added "1.11"
   :static true}
  [f coll]
  (persistent!
   (reduce
    (fn [ret x]
      (assoc! ret (f x) x))
    (transient {}) coll)))

I've been using this function for years especially for indexing a database result. Often, you have a vector of maps where each map has a unique ID, and you need to build a map like ID => row. Why don't instroduce such a function? I can create a PR.

`ClassCastException` when misplacing `nth` args

Mon, 11 Dec 2023 05:42:28 +0000

I accidentally misplaced the args to nth and was presented with the following error and stacktrace:

  Show: Project-Only All 
  Hide: Clojure Java REPL Tooling Duplicates  (0 frames hidden)

2. Unhandled clojure.lang.Compiler$CompilerException
   Error compiling NO_SOURCE_FILE at (79:3)
   #:clojure.error{:phase :execution,
                   :line 79,
                   :column 3,
                   :source "NO_SOURCE_FILE"}
             Compiler.java: 3719  clojure.lang.Compiler$InvokeExpr/eval
             Compiler.java:  457  clojure.lang.Compiler$DefExpr/eval
             Compiler.java: 7199  clojure.lang.Compiler/eval
             Compiler.java: 7149  clojure.lang.Compiler/eval
                  core.clj: 3215  clojure.core/eval
                  core.clj: 3211  clojure.core/eval
    interruptible_eval.clj:   87  nrepl.middleware.interruptible-eval/evaluate/fn/fn
                  AFn.java:  152  clojure.lang.AFn/applyToHelper
                  AFn.java:  144  clojure.lang.AFn/applyTo
                  core.clj:  667  clojure.core/apply
                  core.clj: 1990  clojure.core/with-bindings*
                  core.clj: 1990  clojure.core/with-bindings*
               RestFn.java:  425  clojure.lang.RestFn/invoke
    interruptible_eval.clj:   87  nrepl.middleware.interruptible-eval/evaluate/fn
                  main.clj:  437  clojure.main/repl/read-eval-print/fn
                  main.clj:  437  clojure.main/repl/read-eval-print
                  main.clj:  458  clojure.main/repl/fn
                  main.clj:  458  clojure.main/repl
                  main.clj:  368  clojure.main/repl
               RestFn.java: 1523  clojure.lang.RestFn/invoke
    interruptible_eval.clj:   84  nrepl.middleware.interruptible-eval/evaluate
    interruptible_eval.clj:   56  nrepl.middleware.interruptible-eval/evaluate
    interruptible_eval.clj:  152  nrepl.middleware.interruptible-eval/interruptible-eval/fn/fn
                  AFn.java:   22  clojure.lang.AFn/run
               session.clj:  202  nrepl.middleware.session/session-exec/main-loop/fn
               session.clj:  201  nrepl.middleware.session/session-exec/main-loop
                  AFn.java:   22  clojure.lang.AFn/run
               Thread.java:  829  java.lang.Thread/run

1. Caused by java.lang.ClassCastException
   class clojure.lang.PersistentVector cannot be cast to class
   java.lang.Number (clojure.lang.PersistentVector is in unnamed module of
   loader 'app'; java.lang.Number is in module java.base of loader
   'bootstrap')

                      REPL:   82  advent-of-clerk.year-2023.day-04/fn
                      REPL:   79  advent-of-clerk.year-2023.day-04/fn
                  AFn.java:  152  clojure.lang.AFn/applyToHelper
                  AFn.java:  144  clojure.lang.AFn/applyTo
             Compiler.java: 3714  clojure.lang.Compiler$InvokeExpr/eval
             Compiler.java:  457  clojure.lang.Compiler$DefExpr/eval
             Compiler.java: 7199  clojure.lang.Compiler/eval
             Compiler.java: 7149  clojure.lang.Compiler/eval
                  core.clj: 3215  clojure.core/eval
                  core.clj: 3211  clojure.core/eval
    interruptible_eval.clj:   87  nrepl.middleware.interruptible-eval/evaluate/fn/fn
                  AFn.java:  152  clojure.lang.AFn/applyToHelper
                  AFn.java:  144  clojure.lang.AFn/applyTo
                  core.clj:  667  clojure.core/apply
                  core.clj: 1990  clojure.core/with-bindings*
                  core.clj: 1990  clojure.core/with-bindings*
               RestFn.java:  425  clojure.lang.RestFn/invoke
    interruptible_eval.clj:   87  nrepl.middleware.interruptible-eval/evaluate/fn
                  main.clj:  437  clojure.main/repl/read-eval-print/fn
                  main.clj:  437  clojure.main/repl/read-eval-print
                  main.clj:  458  clojure.main/repl/fn
                  main.clj:  458  clojure.main/repl
                  main.clj:  368  clojure.main/repl
               RestFn.java: 1523  clojure.lang.RestFn/invoke
    interruptible_eval.clj:   84  nrepl.middleware.interruptible-eval/evaluate
    interruptible_eval.clj:   56  nrepl.middleware.interruptible-eval/evaluate
    interruptible_eval.clj:  152  nrepl.middleware.interruptible-eval/interruptible-eval/fn/fn
                  AFn.java:   22  clojure.lang.AFn/run
               session.clj:  202  nrepl.middleware.session/session-exec/main-loop/fn
               session.clj:  201  nrepl.middleware.session/session-exec/main-loop
                  AFn.java:   22  clojure.lang.AFn/run
               Thread.java:  829  java.lang.Thread/run

I was having a hard time spotting the problem, as I was changing a few things at once. Ultimately I realized that I've misplaced the collection and the index arguments to nth, but the stacktrace did little to help me realize that: there is no mention of call to nth there, and the line numbers are not pointing exactly to the problematic line.

The complete example code here: https://github.com/a1exsh/advent-of-clerk/blob/cddd42fcd60da2efcda37f222666328cd37fb616/src/advent_of_clerk/year_2023/day_04.clj#L84 (this is the correct code — to get the error swap the arguments like this: (nth i untouched))

The environment where I was hitting this is evaluating the single loop form in CIDER (Emacs) with C-x C-e.

It can be readily reproduced in REPL of course, just like this:

user> (nth 0 [])
Execution error (ClassCastException) at user/eval22783 (REPL:42).
class clojure.lang.PersistentVector cannot be cast to class java.lang.Number (clojure.lang.PersistentVector is in unnamed module of loader 'app'; java.lang.Number is in module java.base of loader 'bootstrap')

RT/chunkIteratorSeq does not produce a chunked-seq?

Thu, 16 Nov 2023 15:05:15 +0000

user> (def al (hamf/array-list (range 200))) 
#'user/al
user> (type al)
java.util.ArrayList
user> (chunked-seq? (seq al))
false
user> (instance? java.lang.Iterable al)
trueSyntax error reading source at (REPL:65:41).
Unmatched delimiter: )
user> (instance? java.lang.Iterable al)
true
user> (chunked-seq? (clojure.lang.RT/seq al))
false
user> (chunked-seq? (clojure.lang.RT/chunkIteratorSeq (.iterator al)))
false
user> (type (clojure.lang.RT/chunkIteratorSeq (.iterator al)))
clojure.lang.LazySeq

If no lazy seq is a chunked seq then the result of clojure.core/map, filter, etc. also cannot ever be a chunked seq as they are currently written. There are just a whole lot of questions here.

rand-int should check its arg before calling rand

Fri, 10 Nov 2023 17:15:30 +0000

The current source code for rand-int is (abridged):

(defn rand-int [n] (int (rand n)))

but this means it can take an arg >Integer/MAX_VALUE and randomly throw overflow exceptions:

(rand-int (* Integer/MAX_VALUE 2.0))
;; => Execution error (ArithmeticException) at java.lang.Math/toIntExact (Math.java:1135).
;;    integer overflow

(rand-int (* Integer/MAX_VALUE 2.0))
;; => 1536421981

etc.
I can see that being able pass a float or double could be useful for "weighting" the range:

(/ (reduce + 0 (map (fn [_] (rand-int 2.5)) (range 1e8)))
   1e8)
;; => 0.79993543

(/ (reduce + 0 (map (fn [_] (rand-int 2)) (range 1e8)))
   1e8)
;; => 0.49998904

but to be honest I think this is probably not immediately apparent to a lot of users.

So, if you want that to allow that behaviour, source code could look something like this:

(defn rand-int [n] (int n) (int (rand n)))

And if you didn't it could look something like this:

(defn rand-int [n] (int (rand (int n))))

But as it currently stands, we don't coerce to an integer, or even check that the input is within Integer range, leading to random overflow exceptions. And random exceptions seem like a bad thing, even for a function called rand-int.

clojure.lang.LazySeq synchronized methods pin virtual thread

Sat, 23 Sep 2023 07:31:15 +0000

Hi
I have a service written in Clojure 1.11 and service is running on Jetty 12.
I tried to run service on Java 21 using virtual threads in Jetty.
There are following constraints preventing virtual thread's unmounting:

A virtual thread cannot be unmounted during blocking operations when
it is pinned to its carrier. A virtual thread is pinned in the
following situations:
- The virtual thread runs code inside a synchronized block or method
- The virtual thread runs a native method or a foreign function (see Foreign Function and Memory API)

i ran service with '-Djdk.tracePinnedThreads=full' key and found that LazySeq
synchronized LazySeq methods pin the virtual thread:

clojure.lang.LazySeq.sval(LazySeq.java:42) <== monitors:1
clojure.lang.LazySeq.seq(LazySeq.java:51) <== monitors:1

(By the way, same problem is raised by synchornized Delay deref method)

As i see Clojure stdlib implementation and Clojure internal stuff itsself use 'synchronized' approach heavily which is incompatible with virtual thread constraints.
I understand that there is a huge amount of code and it is mega expensive to adapt it to be virtual thread's friendly but maybe there are some plans about being compatible with virtual threads constraints.

Thanks!

Immutable wrapper around Java arrays?

Mon, 28 Aug 2023 11:20:27 +0000

Are there any immutable wrapper around Java arrays in Clojure, similar to Scala's ArraySeq?

What are your thoughts on introducing such a wrapper to Clojure's core?

Common operations to set var root - why not in clojure.core?

Mon, 07 Aug 2023 09:10:44 +0000

I have been using the following function a lot:

 (defn set-var-root [v value]
   (alter-var-root v (constantly value)))

And I have seen this pattern a lot in other code too. It is like an idiom if I understand correctly.
Why is it not in clojure.core?

Might it be a good addition and if not, why not?

I have asked in clojurians slack and was pointed out to

(.bindRoot avar value)

Which I didn't know before also. But again the question why is it not part of the public API? Is there something wrong with using vars like this?

To give some context, I am developing a game engine and on app start I am setting global vars for input, graphics context, etc.

https://github.com/damn/gdl/blob/main/src/gdl/game.clj#L13

(defn- load-gdx-globals []
  (set-var-root #'gdl.app/app           Gdx/app)
  (set-var-root #'gdl.files/files       Gdx/files)
  (set-var-root #'gdl.graphics/graphics Gdx/graphics)
  (set-var-root #'gdl.input/input       Gdx/input))

what does ^:once meta applied for anon function mean?

Sun, 02 Jul 2023 13:07:57 +0000

hi!
what does ^:once meta applied for anon function mean?

(db-query-with-resultset* db sql params
                           (^:once fn* [rset]
                             (process-result-set rset opts))
                          opts)

Thanks

Is there any performance difference between creating vector via (into [] xs) or (vec xs)?

Sat, 03 Jun 2023 11:35:12 +0000

I can create set/map/vector by two ways:

(into #{} xs) ;; creates PersistentHashSet
(set xs)      ;; creates PersistentHashSet

(into {} xs)  ;; creates PersistentArrayMap or PersistentHashMap (depends on xs size) 
(apply hash-map xs) ;; creates PersistentHashMap

(into [] xs)  ;; creates PersistentVector
(vec xs)      ;; creates PersistentVector

(into r xs):
- defines generic algorithm by conj!-ing input sequence 1 by 1 to passed result collection (uses transient/persistent trick)

(ctor xs):
- defines precisely type of result data structure
- passes xs sequence as an argument to constructor (which is static java function) so every ctor may define its own logic of creation (maybe by not conj-ing input sequence 1 by 1)

Are there any performance differences between these two ways?
Maybe there is an established idiom what to use when?

Thanks!

best way to conditionally def a symbol and do some side effect if symbol does not exist?

Fri, 12 May 2023 10:38:38 +0000

I was surprised that this code in dev/user.clj doesn't run at start up:

(ns user) ; user ns is loaded by REPL startup

(println "Evaluating dev/user.clj")
(when-not (resolve 'xxx)
  (def xxx 1)
  (println "defing xxx"))

This worked for me:

(defonce yyy (let [tmp 1] (println (str "deffing yyy as " tmp))
                   tmp))

Something like this was also suggested to me in the clojurians
[https://clojurians.slack.com/archives/C053AK3F9/p1683882344251029][Slack] :

(ns user)

(when-not (resolve 'xxx)
  (intern 'user 'xxx 42)
  (prn "!!!"))

Clojure equivalent of kotlins '?'

Wed, 29 Mar 2023 06:27:40 +0000

Kotlin has a '?' operator which can be used to handle nullable types:

fun f(nullable: String?) {
  val nullable_length = nullable?.length;
  val length_or_zero = nullable_length ?: 0;
  val prefixed_nullable = nullable?.let {
    "prefix_" + it
  }
}

Here, nullable_length is either an integer or null. length_or_zero is either the length of string or 0 if it was null. prefixed_nullable is either null or the original string with a prefix, depending on whether it was null.

What is the clojure equivalent of this feature for dealing with nils?

calling take-nth with 0 causes an OutOfMemoryError, and kills the repl.

Wed, 08 Mar 2023 07:59:54 +0000

calling take-nth with 0 causes an OutOfMemoryError, and kills the repl. Perhaps a validation > 0 required here?

to reproduce,

user=> (take-nth 0 [1 2])
OutOfMemoryError Java heap space
        reply.eval-modes.nrepl/session-responses (nrepl.clj:51)
        reply.eval-modes.nrepl/session-responses (nrepl.clj:51)
        reply.eval-modes.nrepl/session-responses/fn--1340 (nrepl.clj:56)
        clojure.lang.LazySeq.sval (LazySeq.java:42)
        clojure.lang.LazySeq.seq (LazySeq.java:51)
        clojure.lang.RT.seq (RT.java:535)
        clojure.core/seq--5467 (core.clj:139)
        clojure.core/filter/fn--5962 (core.clj:2826)
        clojure.lang.LazySeq.sval (LazySeq.java:42)
        clojure.lang.LazySeq.seq (LazySeq.java:58)
        clojure.lang.RT.seq (RT.java:535)
        clojure.core/seq--5467 (core.clj:139)
Bye for now!
Error printing return value (OutOfMemoryError) at clojure.core/take-nth (core.clj:4289).

Using proxy to extend MemoryStream fails on Close

Sun, 15 Jan 2023 00:08:50 +0000

For some unit tests, I need to be able to read the contents of a MemoryStream after it has been closed. As this isn't possible, I want to create a memory stream proxy where the call to Close is a no-op, allowing me to read from it even when code outside of my control has attemped closing it. This however won't work.

REPL

(import [System.IO MemoryStream StreamWriter])
(let [stream (proxy [MemoryStream] [] (Close [] (println "close!")))]
  (doto (StreamWriter. stream)
        (.Write "testing")
        (.Close)))

output

close!
Execution error (InvalidProgramException) at System.Diagnostics.StackFrame/Write (NO_FILE:0).
Cannot create boxed ByRef-like values.

While it's evident my proxied Close method is called, an error is thrown just after.

slurp without encoding prints erroneous warning

Fri, 06 Jan 2023 15:53:49 +0000

ClojureCLR slurp erroneously prints a warning unless encoding is explicitly provided:

$ touch foo

$ clojure -M -e '(slurp "foo")'
""

$ Clojure.Main -e '(slurp "foo")'
WARNING: (slurp f enc) is deprecated, use (slurp f :encoding enc).
""

The cause of this is found in the normalize-slurp-opts function, which differs from the JVM version here.

cant call function from clojure.core, dont know what's messed

Fri, 23 Dec 2022 14:26:05 +0000

So, i've been refreshing the language a bit since im still trying to make my clojure knowledge permanent on long-term memory. Had setup a Remote WSL 2.0 connection to an Arch Linux using VSCode on the host: Windows 11 since i default to developing in Linux for everything.

Problem is simple i guess, but im unable to pinpoint.

trying to call (read-line) from clojure.core renders an Could not resolve symbol: read-line in my Calva's output, which is using Joyride to start the REPL.

isn't core loaded by default? what's going on

;checking if ns is the problem
(ns encoder)

;repl output check
(defn queue [] 0)
(println str (queue))

(def files-list)
;test
(do (print "Name yourself now: ")
    (flush)
    (read-line)) => Could not resolve symbol: read-line

;debug test
(println "Enter (literal) filename to encode> ")
(def input (read-line)) => Could not resolve symbol: read-line
(println (str "File to encode: " input))
;cant call read-line from core? wtf

;finish this
(defn add-queue-confirm [filenames]
  (println "Files to process: " filenames))

Potential race condition in requiring-resolve?

Mon, 31 Oct 2022 05:20:05 +0000

Hello! I've been using a few of the functions from clojure.tools.build.api in a future and I sporadically see this error...

Execution error (IllegalStateException) at clojure.tools.build.api/create-basis (api.clj:154).
Attempting to call unbound fn: #'clojure.tools.build.tasks.create-basis/create-basis

From what I see in tools.build...

(defn create-basis
  ([]
   ((requiring-resolve 'clojure.tools.build.tasks.create-basis/create-basis)))
  ([params]
   ((requiring-resolve 'clojure.tools.build.tasks.create-basis/create-basis) params)))

...the code is only really using requiring-resolve to execute another function. Diving deeper into requiring-resolve I can see that the first call to resolve is not synchronized with the same lock that the serialized-require function uses...

(defn- serialized-require
  [& args]
  (locking clojure.lang.RT/REQUIRE_LOCK
    (apply require args)))

(defn requiring-resolve
  [sym]
  (if (qualified-symbol? sym)
    (or (resolve sym)
        (do (-> sym namespace symbol serialized-require)
            (resolve sym)))
    (throw (IllegalArgumentException. (str "Not a qualified symbol: " sym)))))

First, is it possible requiring-resolve is actually returning clojure.lang.Var$Unbound from the first call to resolve when another thread is in the process of requiring that namespace via serialized-require? Assuming so, should tools.build (and I guess by extension most Clojure code) avoid using the ((requiring-resolve 'some-other/function)) pattern? Is it possible requiring-resolve could be modified to be thread safe?

Thanks!

Add interleave-all (like partition-all is to partition)

Wed, 24 Aug 2022 18:47:25 +0000

At work we have some situations where we need to interleave lazy sequences in such a way that if one sequence is shorter than the other we want elements from the longer sequence to be concatenated after the interleaving runs out of the shorter sequence(s).

The following code could be used -- a slight variant of the existing interleave function:

(defn interleave-all
  "Like interleave, but stops when the longest seq is done, instead of
   the shortest."
  {:copyright "Rich Hickey, since this is a modified version of interleave"}
  ([] ())
  ([c1] (lazy-seq c1))
  ([c1 c2]
   (lazy-seq
    (let [s1 (seq c1) s2 (seq c2)]
      (cond
       (and s1 s2) ; there are elements left in both
       (cons (first s1) (cons (first s2)
                              (interleave-all (rest s1) (rest s2))))
       s1 ; s2 is done
       s1
       s2 ; s1 is done
       s2))))
  ([c1 c2 & colls]
   (lazy-seq
    (let [ss (filter identity (map seq (conj colls c2 c1)))]
      (concat (map first ss) (apply interleave-all (map rest ss)))))))

dedupe and partition-by depending on magic value

Thu, 28 Apr 2022 14:57:11 +0000

I noticed dedupe and the transducer-returning arity of partition-by use the magic value :clojure.core/none to indicate the start of processing. There are some cases where this results in an incorrect result:

;;;; dedupe

(dedupe
 [:clojure.core/none 1 2 3])
;;=> (1 2 3)
;; expected: (:clojure.core/none 1 2 3)

(dedupe
 [:clojure.core/none :clojure.core/none 1 2 3])
;;=> (1 2 3)
;; expected: (:clojure.core/none 1 2 3)

;; transducing arity is also affected
(sequence
 (dedupe)
 [:clojure.core/none 1 2 3])
;;=> (1 2 3)
;; expected: (:clojure.core/none 1 2 3)

;;;; partition-by

(sequence (partition-by
           {0 0
            1 :clojure.core/none
            2 2})
          (range 3))
;;=> ([0] [1 2])
;; expected: ([0] [1] [2])

;; non-trasducing arity works OK:
(partition-by
 {0 0
  1 :clojure.core/none
  2 2}
 (range 3))
;;=> ((0) (1) (2))

Is this a conscious tradeoff for performance or is it something that might use a bit of additional thinking about better handling?

Shorthand for if-let and when-let combined to not-empty or seq functions

Tue, 05 Apr 2022 12:12:28 +0000

This functions which I think they are usually used could be shortened

(let [coll (get-coll)]
  (if (seq coll) 
    (handle-true coll)
    (handle-false)))

(when-let [x (seq ...)])

(if-let [x (seq ...)])

Like:

(if-seq-let [coll (get-coll)]
  (handle-true coll)
  (handle-false))

(when-seq-let [c (get-coll)]
  (handle-true1 coll)
  (handle-true2 coll))

Proposal based on if-let and when-let.

(defmacro ^{:private true} assert-args
  [& pairs]
  `(do (when-not ~(first pairs)
         (throw (IllegalArgumentException.
                  (str (first ~'&form) " requires " ~(second pairs) " in " ~'*ns* ":" (:line (meta ~'&form))))))
       ~(let [more (nnext pairs)]
          (when more
            (list* `assert-args more)))))

(defmacro if-seq-let
  "bindings => binding-form test

  If test is seq, evaluates then with binding-form bound to the value of
  test, if not, yields else"
  ([bindings then]
   `(if-let ~bindings ~then nil))
  ([bindings then else & oldform]
   (assert-args
     (vector? bindings) "a vector for its binding"
     (nil? oldform) "1 or 2 forms after binding vector"
     (= 2 (count bindings)) "exactly 2 forms in binding vector")
   (let [form (bindings 0) tst (bindings 1)]
     `(let [temp# ~tst]
        (if (seq temp#)
          (let [~form temp#]
            ~then)
          ~else)))))

(defmacro when-seq-let
  "bindings => binding-form test

  When test is seq, evaluates body with binding-form bound to the value of test"
  [bindings & body]
  (assert-args
    (vector? bindings) "a vector for its binding"
    (= 2 (count bindings)) "exactly 2 forms in binding vector")
  (let [form (bindings 0) tst (bindings 1)]
    `(let [temp# ~tst]
       (when (seq temp#)
         (let [~form temp#]
           ~@body)))))

Hash collisions in case statements try to evaluate the constants

Mon, 13 Dec 2021 20:54:22 +0000

When case statements use hashing and have a hash collision, they embed a condp expression. However, this expression inserts the constants directly, without quoting. If any constants include a symbol, then these will lead to an error.

For example:

(case 'a #{a} 1 :foo 2 a 3)

Leads to: Unable to resolve symbol: a in this context

This can be seen when expanding the macro:

(macroexpand '(case 'a #{a} 1 :foo 2 a 3))
(let* [G__151 (quote a)] (case* G__151 0 1 (throw (java.lang.IllegalArgumentException. (clojure.core/str "No matching clause: " G__151))) {0 [-1640525200 (clojure.core/condp clojure.core/= G__151 #{a} 1 a 3 (throw (java.lang.IllegalArgumentException. (clojure.core/str "No matching clause: " G__151))))], 1 [:foo 2]} :compact :hash-equiv #{0}))

This shows a call to case*. The first and second arguments are 0, 1. When these are used with clojure.core/shift-mask both '#{a} and 'a will hash to 0.

The 5th argument contains a map of hash codes to values, which contains:

{0 [-1640525200 (clojure.core/condp clojure.core/= G__151
                  #{a} 1
                  a 3
                  (throw (java.lang.IllegalArgumentException. (clojure.core/str "No matching clause: " G__151))))],
 1 [:foo 2]}

This condp block contains unquoted values for #{a} and a, so they will incorrectly attempt to match on the value of the current binding for a (if such a binding exists).

Since case will interpret every test-constant as a literal (explicitly stating that they need not be quoted), these values should be quoted when they appear in an embedded Clojure expression like this this condp.

The following is a suggested patch to correct the generated code:

diff --git a/src/clj/clojure/core.clj b/src/clj/clojure/core.clj
index 0dba6fcd..b21d4556 100644
--- a/src/clj/clojure/core.clj
+++ b/src/clj/clojure/core.clj
@@ -6690,7 +6690,7 @@ fails, attempts to require sym's namespace and retries."
                       (next ks) (next vs))
                     m))
         assoc-multi (fn [m h bucket]
-                      (let [testexprs (apply concat bucket)
+                      (let [testexprs (mapcat (fn [kv] [(list 'quote (first kv)) (second kv)]) bucket)
                             expr `(condp = ~expr-sym ~@testexprs ~default)]
                         (assoc m h expr)))
         hmap (reduce1
diff --git a/test/clojure/test_clojure/control.clj b/test/clojure/test_clojure/control.clj
index 92846ad3..f3fe436b 100644
--- a/test/clojure/test_clojure/control.clj
+++ b/test/clojure/test_clojure/control.clj
@@ -421,7 +421,14 @@
          :b 1
          :c -2
          :d 4294967296
-         :d 3))
+         :d 3)
+    (are [result input] (= result (case input
+                                    #{a} :set
+                                    :foo :keyword
+                                    a :symbol))
+         :symbol 'a
+         :keyword :foo
+         :set '#{a}))
   (testing "test warn for hash collision"
     (should-print-err-message
      #"Performance warning, .*:\d+ - hash collision of some case test constants; if selected, those entries will be tested sequentially..*\r?\n"

Does the `any?` function have the correct behavior?

Tue, 09 Nov 2021 22:30:57 +0000

Clojure's any? function seems to just return true always.
(defn any? "Returns true given any argument." {:tag Boolean :added "1.9"} [x] true)

Contrast this with not-any?.
(def ^{:tag Boolean :doc "Returns false if (pred x) is logical true for any x in coll, else true." :arglists '([pred coll]) :added "1.0"} not-any? (comp not some))

I believe any? should take two arguments and return true if any predicate is true.
(def ^{:tag Boolean :doc "Returns true if (pred x) is logical true for any x in coll, else false." :arglists '([pred coll]) :added "1.9"} any? (comp boolean some))
Credit to Kofrasa on ClojureDocs.

Here are some tests to run:

`
(ns user
(:require [clojure.test :refer [are deftest]]

        [clojure.test.check.clojure-test :refer [defspec]]
        [clojure.test.check.generators :as gen]
        [clojure.test.check.properties :as prop])

(:refer-clojure :exclude [any?]))

(deftest clojure-any
(are [x y] (= ((comp boolean some) true? x) (clojure.core/any? y))

[true] true
[false] false ;; this fails
[true true] true
[false true] true
[false false] false ;; so does this
))

(def
^{:tag Boolean
:doc "Returns true if (pred x) is logical true for any x in coll,
else false."
:arglists '([pred coll])
:added "1.9"}
any? (comp boolean some))

(defspec correct-any 1000
(prop/for-all [v (gen/such-that not-empty (gen/vector gen/boolean))]

            (= ((comp boolean some) true? v)
               (any? true? v)
               (not (not-any? true? v)))))

Apologies for the messed-up formatting.
https://gist.github.com/wildwestrom/9568e9c659d30a2a663a9a0a8235a6b9

What would transducers-first Clojure look like?

Sat, 02 Oct 2021 19:32:19 +0000

Rich says in the History of Clojure:

I think transducers are a fundamental primitive that decouples critical logic from list/sequence processing and construction, and if I had Clojure to do all over I would put them at the bottom.

This fascinates me, and I am really curious what would transducers-first Clojure look like? I don't really expect Rich to answer here (I should have asked this at his HOPL talk...) but perhaps someone who is closer to core might have some insight.

I would love to see a Clojure where transducers are the default and easiest way to solve things, where all the tutorials and gists and example code everywhere around would be using them and a context (vector, lazy, first etc.) was only chosen at the edges. Currently it is easier (but perhaps not simpler) to write lazy code than transducing code.

I am wondering if transducers-first Clojure would address the above or would it mostly be about the plumbing behind a clojure.core similar to the current one.

For my personal case, I actively have to fight laziness - I don't think I encountered a single place in our codebase where it would be beneficial but as it's still the easiest way of writing clojure I have to put in extra effort to not accidentally venture over to lazy land and to spot these patterns in PRs of others.

I would love a clojure.core2 where transducers are the default, it's easy to write transducing code, potentially with less typing/ceremonies, the likes of comp and into [] etc. And stepping over to lazy land is always an opt-in thing, like the impure parts of clojure - stm, transients etc. I'm not entirely sure how a core library like that would look but it's something I'd love to try.

Moreover, there are some transducer-specific optimisations like https://github.com/cgrand/xforms#on-key-value-pairs that could be considered. And perhaps there could also be a way to use the multiple-coll arities of map as part of a transducer somehow.

There could also be more baked-in support for an xform arg in functions that currently take a coll to preprocess them, like run! and str/join - if you actively use transducers you start to notice things like 'hey, I don't even need a collection there' and start to look for different transducing contexts - so instead of (count (into [] xform input)) you'd go (x/count xform input)

using `proxy` might make an otherwise additive change breaking

Tue, 30 Mar 2021 10:33:11 +0000

Given an interface

public interface Foo {
    void bar(Object o);
}

And a proxy over that interface:

(proxy [Foo] []
  (bar [o] (baz o)))

When the interface gets updated to

public interface Foo {
  void bar(Object o);

  // java 8 default method, quote from 
  // https://docs.oracle.com/javase/tutorial/java/IandI/defaultmethods.html
  // "Default methods enable you to add new functionality to the
  // interfaces of your libraries and ensure binary compatibility
  // with code written for older versions of those interfaces."
  default void bar(Object o, Object p) {
    bar(o);
  }
}

Calls to instanceCreatedByProxy.bar(o, p) will not work as it could be expected.

reify is not affected by this.

Repro repo: https://github.com/imrekoszo/proxy-default

There is no indication of this behavior in the docstring of proxy, the only reference I saw to this is an example on clojuredocs.

This is troublesome as it might prevent an otherwise non-breaking library upgrade. If the code calling proxy is under one's control they could use reify instead (especially as this is recommended in the official docs). However if it is in an external library this is not a viable workaround.

Is this a bug or a known limitation of proxy?
If the latter, then could this perhaps be made more visible, for example through a warning in the docstring?

Edit:
- link to original slack thread
- added link to reify recommendation

Unnecessary check in case?

Sun, 28 Feb 2021 10:07:12 +0000

Given

(let [c (char 110)]
        (case c \n (println "lol")))

If I run decompile from https://clojars.org/com.clojure-goes-fast/clj-java-decompiler
I get the following output:

public final class json$fn__15103 extends AFunction {
public static final Object const__2;
public static final Var const__3;
public static final Var const__4;

public static Object invokeStatic() {
    final char G__15104;
    final char c = G__15104 = RT.charCast(110L);
    switch (Util.hash(G__15104)) {
        case 110: {
            if (Util.equiv((Object)G__15104, json$fn__15103.const__2)) {
                return ((IFn)json$fn__15103.const__3.getRawRoot()).invoke("lol");
            }
            break;
        }
    }
    throw new IllegalArgumentException((String)((IFn)json$fn__15103.const__4.getRawRoot()).invoke("No matching clause: ", G__15104));
}

@Override
public Object invoke() {
    return invokeStatic();
}

static {
    const__2 = 'n';
    const__3 = RT.var("clojure.core", "println");
    const__4 = RT.var("clojure.core", "str");
} 
}

My question is (given that this decompilation is correct) why does the compiler emit the if test, and more interestingly, is there a way to get rid of it (by means of instructing the compiler?).

It might also be that I should not care about this because the JIT will take care of it for me, but still.

Also, one could argue, I guess, that since we know that the thing I'm case'ing on is a char there would be no need to do a Util.hash on it?

clojure.core/case behaves weirdly for certain inputs

Wed, 06 Jan 2021 00:59:43 +0000

case seems to behave inconsistently for collections containing java.lang.Integers.
For example, take this function:

(defn test-case [v]
  (case v
    [1 -1] :one
    [1] :two
    :default))

Calling it with [1 -1] or [1] as an argument yields the expected result, and so does calling it with [(int 1)] (=> :one). However, with two elements, this does not work anymore:

(test-case [(int 1) (int -1)]) => :default

To me this seems like a bug, considering that (= [1 -1] [(int 1) (int -1)]) => true.

Is there anything I'm missing here?

This was tested on Clojure version 1.10.1.547.

Edit: only now saw the relevant issue. Sorry about that.

Suspected bug in `clojure.core/partition`

Thu, 10 Dec 2020 02:54:45 +0000

2 problems:
- The docstring of clojure.core/partition is not clear on what "last partition" means.
- The behavior of partition is strange, IHMO it has a bug.

Please take a look at this:

(partition 3 1 [:a :b :c] (range 5))

; actual behavior
; => ((0 1 2) (1 2 3) (2 3 4) (3 4 :a))

; expected behavior, option 1
; => ((0 1 2) (1 2 3) (2 3 4))

; expected behavior, option 2
; => ((0 1 2) (1 2 3) (2 3 4) (3 4 :a) (4 :a :b))

I would expect the "last partition" to be defined as:

The last partition to contain elements from the input collection (not the padding collection) which are not present in any previous partition.

This is consistent with option 1 above.