Clojure Q&A - Questions without answers in Clojure

Possibly avoidable identity call to force instance method on Class literals

Thu, 02 Jul 2026 23:47:10 +0000

As of Clojure 1.13.0-alpha2, (.method ClassName) expands to (.method ^Class (identity ClassName)).

This is to force (.method ClassName) to always be an instance method. Without this, it would expand to (. ClassName method), which may instead be interpreted as a static method.

For example, (.getMethods String) expands to (.getMethods ^Class (identity String)).

This was introduced in these two commits:
- force instance member interpretation of (.method ClassName), e.g. (.getMethods String) works
- added autohinting to Class in macroexpansion of (.instanceMethodOfClass Classname) calls

Since then, Clojure has added support for qualified methods which we can use to reliably propagate the tag without any runtime changes. For example, expanding to (Class/.getMethods String) is now equivalent to (.getMethods ^Class (identity String)) in terms of tag propagation.

I have a proof-of-concept here that includes disassembled and decompiled output before and after the change. The net effect of using qualified methods in this case under direct linking is a removal of a single method call to identity:

   3: invokestatic  #20                 // Method clojure/core$identity.invokeStatic:(Ljava/lang/Object;)Ljava/lang/Object;

The effect is more substantial without direct linking (not included in the PR), with clojure.core/identity also being added to the static initializer.

I've also experimented with expanding to (. (do String) getMethods) (see earlier commits in that PR), which seems to also work and might be another approach.

Syntax-quoted lists can return nil, differs from ClojureScript

Sun, 28 Jun 2026 20:43:55 +0000

Syntax quoted lists can return nil if only empty seqables are spliced into it:

Clojure 1.12.5
user=> `(~@[])
nil
user=> `(~@[] ~@[])
nil

However, the implementation then ensures syntax-quoted empty lists are not nil:

Clojure 1.12.5
user=> `()
()

ClojureScript returns an empty list in these cases:

`(~@[])
=> ()
`(~@[] ~@[])
=> ()

The expansion of syntax quote itself is not necessarily a problem if it differs between platforms, but here the evaluation of the expansion differs. This can cause macros to behave differently between platforms (e.g., JVM Clojure vs bootstrapped cljs).

This behavior seems to be present with all versions of Clojure including 1.0.0, so perhaps the ship has sailed here. I went searching for an existing issue or documentation and AFAICT only CLJ-1425 mentions this oddity.

The reference docs for Syntax Quote also seem to contradict this behavior:

For Lists/Vectors/Sets/Maps, syntax-quote establishes a template of the corresponding data structure.

Consider including a built-in wrapper around `java.net.http.HttpClient` in future versions of Clojure

Mon, 08 Jun 2026 01:37:14 +0000

Java 9 introduced java.net.http.HttpClient[1] with support for HTTP/1.1, HTTP/2 as well as WebSocket along with other features. It was later standardized in Java 11[2] and has become one of the top picks for Java programs. The latest version of the HTTP client shipped with Java 26 also added support for HTTP/3.[3]

It would be nice for future versions of Clojure that are based on Java 11+ to include a new namespace with wrapper functions around java.net.http.HttpClient to make it easier (without all the OOP ceremonies) to work with HTTP in Clojure programs out of the box without relying on any 3rd-party libraries.

Examples of prior art:

[1] https://openjdk.org/jeps/110
[2] https://openjdk.org/jeps/321
[3] https://openjdk.org/jeps/517

Request: allow a user function to be specified as the target of clojure.main/report-error

Tue, 02 Jun 2026 23:53:32 +0000

The three current targets (file, none, stderr) all serialize all of the error data to a string. During development, it would be convenient to be able to define a function that is called with the exception instance. This function might capture additional application state, or open a window in the user's editor, etc.

Note that it is not possible to work around this by replacing report-error itself because the entire clojure.main namespace is AOT-compiled, so alter-var-root has no effect.

See https://github.com/clojure-emacs/cider/issues/3850 for an example where this feature would be helpful.

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!

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"

`(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.

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?

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.

`(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 !

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.

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.

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

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.

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.

"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

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.

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!

Links to EPL license are now broken

Wed, 23 Aug 2023 17:16:20 +0000

Links such as https://github.com/clojure/clojure/blob/2a058814e5fa3e8fb630ae507c3fa7dc865138c6/test/clojure/test_clojure/protocols.clj#L3C33-L3C79 direct one to a 404 page.

problem with Null exception in cl-format

Wed, 16 Aug 2023 14:36:19 +0000

If the format string ends in ~@, there is code in cl-format to detect this
and issue a format-error. However, that error detection is wrong, and a null exception
happens rather than the format-error being reported.

To reproduce this, simply evaluate the following.

clojure.pprint> (cl-format false "~@")
Execution error (NullPointerException) at nrepl.middleware.interruptible-eval/evaluate$fn$fn (interruptible_eval.clj:87).

I have a fix for this which I'd like to contribute.

Here is the new version of the code compile-directive

(defn- compile-directive [s offset]
  (let [[raw-params [rest offset]] (extract-params s offset)
        [_ [rest offset flags]] (extract-flags rest offset)
        directive (first rest)
        ;; previous version was missing (if directive ...) here thus (format-error ...) never reached
        def (if directive (get directive-table (Character/toUpperCase ^Character directive)))
        params (if def (map-params def (map translate-param raw-params) flags offset))]
    (if (not directive)
      (format-error "Format string ended in the middle of a directive" offset))
    (if (not def)
      (format-error (str "Directive \"" directive "\" is undefined") offset))
    [(struct compiled-directive ((:generator-fn def) params offset) def params offset)
     (let [remainder (subs rest 1) 
           offset (inc offset)
           trim? (and (= \newline (:directive def))
                      (not (:colon params)))
           trim-count (if trim? (prefix-count remainder [\space \tab]) 0)
           remainder (subs remainder trim-count)
           offset (+ offset trim-count)]
       [remainder offset])]))

The old version

Channel for real-time conversation on Freenode irc, visit: https://webchat.freenode.net/

Fri, 04 Aug 2023 14:56:52 +0000

visit: https://webchat.freenode.net/
in channel, type: #clojure
remember that this channel of ours is there for everyone to clear up doubts, talk but above all maintain respect for the next person.
Enjoy it!

Locals clearing issue with a type-hinted vs non-type-hinted letfn?

Fri, 16 Jun 2023 16:19:58 +0000

Hey folks - I seem to be getting a locals clearing issue with a type-hinted vs non-type-hinted letfn:

(defn- letfn-prim []
  (letfn [(f [coll ^long n]
            )]
    (f (take 3 (range)) 0)))

(defn- letfn-noprim []
  (letfn [(f [coll n]
            )]
    (f (take 3 (range)) 0)))

(in practice, I'm lazily processing coll within f and wanted to avoid retaining the head)

The noprim variant clears the coll param correctly; the prim version doesn't seem to.

(I'm aware letfn doesn't fully support type-hints, but this one seems to be more than just an unexpected boxing, and affects more than just the hinted variable)

In both cases, the caller is calling f.invoke(Object) (invokeinterface clojure/lang/IFn.invoke:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;), but the difference comes in the f function. (Arguably the hinted version could call invokePrim directly, but as I say, aware letfn doesn't fully support type-hints)

In the unhinted case, invoke is trivial:

  public java.lang.Object invoke(java.lang.Object, java.lang.Object);
    Code:
       0: aconst_null
       1: areturn

(adding more of a body clears the param as soon as it can)

but in the hinted case, we get this:

  public final java.lang.Object invokePrim(java.lang.Object, long);
    Code:
       0: aconst_null
       1: areturn

  public java.lang.Object invoke(java.lang.Object, java.lang.Object);
    Code:
       0: aload_0
       1: aload_1
       2: aload_2
       3: checkcast     #22                 // class java/lang/Number
       6: invokestatic  #28                 // Method clojure/lang/RT.longCast:(Ljava/lang/Object;)J
       9: invokeinterface #30,  4           // InterfaceMethod clojure/lang/IFn$OLO.invokePrim:(Ljava/lang/Object;J)Ljava/lang/Object;
      14: areturn

The invoke calls through to invokePrim as normal, but it doesn't clear its locals before doing so. compare to

(defn- defn-prim [coll ^long n]
  )

whose bytecode does clear the object in its invoke method:

  public static java.lang.Object invokeStatic(java.lang.Object, long);
    Code:
       0: aconst_null
       1: areturn

  public java.lang.Object invoke(java.lang.Object, java.lang.Object);
    Code:
       0: aload_1
       1: aconst_null
       2: astore_1      // <--- local cleared here
       3: aload_2
       4: checkcast     #21                 // class java/lang/Number
       7: invokestatic  #27                 // Method clojure/lang/RT.longCast:(Ljava/lang/Object;)J
      10: invokestatic  #29                 // Method invokeStatic:(Ljava/lang/Object;J)Ljava/lang/Object;
      13: areturn

  public final java.lang.Object invokePrim(java.lang.Object, long);
    Code:
       0: aload_1
       1: aconst_null
       2: astore_1
       3: lload_2
       4: invokestatic  #29                 // Method invokeStatic:(Ljava/lang/Object;J)Ljava/lang/Object;
       7: areturn

Cheers!

James

Performance improvements to creation of small vectors with TransientVector

Tue, 13 Jun 2023 12:52:56 +0000

Sorry for doing it backward and submitting the ticket /patch first. The ticket is here: https://clojure.atlassian.net/jira/software/c/projects/CLJ/issues/CLJ-2786

The ticket contains all the important details, benchmarking results, and code. Here I would like to hear whether people generally use transients, how they decide if transients will lead to performance improvement rather than degradation, and any other possible doubts. I always had mixed feelings when doing something through transients, probably due to a section in Joy of Clojure claiming that transients are inefficient for small inputs. The benchmark done with the current version of Clojure overall confirms that.

Run a task parallely to delete tags

Sun, 04 Jun 2023 23:21:53 +0000

(defn- find-story-ids-by-tag [tag-id]

(map :id (db-content-tag/read-contents-by-tag-id (config/db-spec) tag-id)))

(defn- update-story [txn publisher-id story-id tag-id]
(let [{:keys [published-json]} (db-content/find-by-id txn story-id)

    updated-tags (filter (fn [tag] (not= (:id tag) tag-id)) (:tags published-json))
    _ (db-story/update-published-json-without-timestamps txn publisher-id story-id (assoc published-json :tags updated-tags))]
(log/info {:message "[TAG-DELETION] Updated Story Tags in Published JSON"
           :publisher-id publisher-id
           :tag-id tag-id
           :story-id story-id
           :updated-tags-json updated-tags})))

(defn- delete-tag [publisher-id tag-id]
(let [associated-content-ids (find-story-ids-by-tag tag-id)]

(transaction/with-transaction
  [txn (config/db-spec)]
  (do
    (when (seq associated-content-ids)
      (do
        (doseq [story-id associated-content-ids]
          (update-story txn publisher-id story-id tag-id))
        (db-content-tag/delete-batch-by-tag txn tag-id associated-content-ids)
        (log/info {:message "[TAG-DELETION] Deleted from Content Tag"
                   :publisher-id publisher-id
                   :tag-id tag-id
                   :story-ids associated-content-ids})))
    (db-tag/delete txn publisher-id tag-id)
    (log/info {:message "[TAG-DELETION] Deleted Tag"
               :publisher-id publisher-id
               :tag-id tag-id})))))

(defn run [publisher-id tag-ids]
(comment run 123 [4 5 6])
(try

(do
  (log/info {:message "[TAG-DELETION] started"
             :publisher-id publisher-id
             :tag-ids tag-ids})
  (doseq [tag-id tag-ids] (if (db-tag/find-by-id (config/db-spec) publisher-id tag-id)
                            (delete-tag publisher-id tag-id)
                            (log/info {:message "[TAG-DELETION] Tag Not Found"
                                       :publisher-id publisher-id
                                       :tag-id tag-id})))
  (log/info {:message "[TAG-DELETION] completed"
             :publisher-id publisher-id
             :tag-ids tag-ids}))
(catch Exception e
  (log/exception e {:message "[TAG-DELETION] errored"
                    :publisher-id publisher-id
                    :tag-ids tag-ids}))))

If I have less than 100 tags this works, but say I have 100 000 tags it is very time consuming. How to modify this code which can run in parallel and takes less time? Currently the task uses seq for both deleting and updating the story

how to start a web server in dev mode in an interactive mode with hot reload and refresh

Fri, 12 May 2023 08:20:46 +0000

Hello wonderful clojure community.
I am new to clojure so appologies for my dump question.

I want to write a http server in clojure and for that there a a few libraries/frameworks available. but what is important for me is the interactive development experience, how?

ok, I want to start the server and if I change a module/namespace I want it to be automatically reload (actually I've already achieved this) however on top of it I want the frontend to get refreshed automatically to to refelect the changes. I use hiccup to describe/render my html pages, unfortunately though for any change I need to manually refresh the page.

I know there should be a (websocket based) solution to make this possible.

I want this soution to work with clojure, I do not use/want clojurescrip.

Syntax of sql files for luminus-migrations

Mon, 06 Jun 2022 21:32:59 +0000

Can the luminus-migration library be used with normal MySQL/MariaDB SQL backup files to migrate a database, or is the syntax different?

Background: I'm trying to create and populate the tables of a MariaDB database with SQL scripts stored in the resources/migrations subdirectory. For this I use a project that was created with the Leiningen template luminus. The project uses the luminus-migration library for migration. If I load the SQL script directly (with a mysql client) into the database, the table is created and the data is imported. On the other hand, if I use the command 'lein run migrate', nothing happens.

Clojure and Clojurescript as options for an Electronic Health Record project

Sat, 19 Feb 2022 16:09:36 +0000

I am the founder of a company that is building a next-generation Electronic Health Record system. The software will have both web and mobile UIs and make heavy use of bleeding-edge Natural Language Understanding and Artificial Intelligence.

I am exploring programming language options and am very interested in Clojure because of its functional language paradigm, robust support for concurrency, and reputation for high expressivity, among other things.

I am seeking input about the major pros and cons for this kind of project.

My company website is https://mpathysoftware.com/

Thank you!

Protocol dispatch via interfaces is nondeterministic

Tue, 21 Sep 2021 19:25:07 +0000

If an object is an instance of multiple (unrelated) interfaces that each extend a protocol, the dispatched method will be chosen at random.

(defn reproduce []
  (eval 
    (list 'do
          (list 'ns (gensym))
          '(do (definterface A)
               (definterface B)

               (defprotocol P
                 (a [this]))

               (extend-protocol P
                 A
                 (a [this] :a)
                 B
                 (a [this] :b))
               (a (reify A B))))))

(frequencies
  (repeatedly 100 reproduce))
;=> {:b 52, :a 48}

One solution is to sort interfaces by name before choosing the implementation, so at least the nondeterminism is eliminated. We could go further and also print a warning in this case.

Logged as: https://clojure.atlassian.net/browse/CLJ-2656

(s/form (s/multi-spec ...)) returns a list with non-symbolic objects

Tue, 24 Aug 2021 11:08:11 +0000

My understanding is that s/form is expected to return symbolic lists that can be passed to eval. Forms of multi-spec specs don't behave that way, returning retag as evaluated value (e.g. a function instance).

(defn retag [x v]
  (assoc (vec x) 0 v))

(defmulti command first)

(s/form (s/multi-spec command retag))
=> (clojure.spec.alpha/multi-spec 
    current.ns/command
    #object[current.ns$retag 0x708d0436 current.ns$retag@708d0436])

;; should be something like
=> (clojure.spec.alpha/multi-spec 
    current.ns/command 
    current.ns/retag)

Could we expose the data behind ranges?

Sat, 10 Jul 2021 12:45:09 +0000

dtype-next, libpython-clj, and tech.ml.dataset all assign special meaning to ranges but they often have to deconstruct them to do so. For libpython, we create actual python ranges in some cases. For dtype-next and friends, a range with increment of 1 may indicate a sub-buffer operation as opposed to an indexed-buffer operation -- sub-buffer retains the ability for System/arraycopy and the like to work correctly and is thus a major optimization in some cases.

I would like to be able to get the start, step, and end (when it exists) from any object created via clojure.core/range. I can currently do this via reflection or via subtraction of the first and second members of the sequence generated via the range along with count but I think it may be a safe and reasonable change to be able to query this information directly.

Most of this could be achieved by simply making the members start, step, and end members of LongRange and Range public as they are already final.

As a separate discussion it may be worth considering having finite ranges work like persistent vectors. I don't want to confuse the above point with this one but it sometimes more efficient to index into ranges via nth or an IFn invoke pathway than it is to use Clojure's sequence abstraction. Finite ranges are logically to me more like persistent vectors in nature and potentially they could behave precisely like persistent vectors including w/r/t hashcode, deriving from java.util.RandomAccess, and having conj produce either a new range or a persistent vector depending on if the value fits properly in the sequence.

Unable to run Clara Rules from Java

Sat, 29 May 2021 12:17:53 +0000

Im beginning to learn Clara Rules and wanted to execute them from Java. I'm getting an error when trying to run the code. ExceptionInInitializerError: Syntax error compiling at (example/shopping.clj:2:3). clara.rules.accumulators. I'm attaching the project source for your reference. Could you please help. Please install Maven. Go to your project root directory and to compile the project execute mvn -q compile To run the code mvn -q exec:java -Dexec.mainClass=example.ClaraExampleMain

SourceCode to the project

Should clojure.zip preserve metadata on zipper that is in end state?

Tue, 11 May 2021 20:10:42 +0000

It can be useful to attach arbitrary metadata to a zipper.

When doing so, this metadata is preserved, as far as I can tell, by all zipper operation that return a zipper, except when the end state is reached.

I studied the behaviour with the following code:

(def res
  (let [zloc (vary-meta (czip/vector-zip [1 2 3])
                        assoc :my-app/my-thing 42)
        ops [["down" czip/down]
             ["up" czip/up]
             ["down" czip/down]
             ["right" czip/right]
             ["left" czip/left]
             ["rightmost" czip/rightmost]
             ["leftmost" czip/leftmost]
             ["next" czip/next]
             ["prev" czip/prev]
             ["up" czip/up]
             ["append-child" #(czip/append-child % "append-child")]
             ["down" czip/down]
             ["edit" #(czip/edit % str "-edit")]
             ["up" czip/up]
             ["insert-child" #(czip/insert-child % "insert-child")]
             ["down" czip/down]
             ["right" czip/right]
             ["insert-left" #(czip/insert-left % "insert-left")]
             ["insert-right" #(czip/insert-right % "insert-right")]
             ["rightmost" czip/rightmost]
             ["remove" czip/remove]
             ["replace" #(czip/replace % "replace")]
             ["rightmost" czip/rightmost]
             ["next past last node" czip/next]]]
    (->> (reductions (fn [zloc [_desc f]] (f zloc))
                     zloc
                     ops)
         (map vector (into [["--" "--"]] ops))
         (map (fn [[[desc _f] zloc]]
                {:op-desc desc
                 :end? (czip/end? zloc)
                 :node (czip/node zloc)
                 :root (czip/root zloc)
                 :my-meta (some-> zloc meta :my-app/my-thing)
                 :meta (meta zloc)})))))

If I then search the result:

(filter #(or (:end %)
             (nil? (:my-meta %))
             (nil? (:meta %)))
        res)
;; => ({:op-desc "next past last node",
;;      :end? true,
;;      :node ["insert-child" "insert-left" "1-edit" "insert-right" 2 "replace"],
;;      :root ["insert-child" "insert-left" "1-edit" "insert-right" 2 "replace"],
;;      :my-meta nil,
;;      :meta nil})

As you can see, it looks like all operations preserve my arbitrary metadata except when the returned zipper is in an end state.

There's no value to dumping the full results from above, but let's look at an arbitrary single result, just to show what things look like when we are not in the zipper end state:

(nth res 11)
;; => {:op-desc "append-child",
;;     :end? false,
;;     :node [1 2 3 "append-child"],
;;     :root [1 2 3 "append-child"],
;;     :my-meta 42,
;;     :meta
;;     {:zip/branch? #function[clojure.core/vector?--5431],
;;      :zip/children #function[clojure.core/seq--5419],
;;      :zip/make-node #function[clojure.zip/vector-zip/fn--9351],
;;      :my-app/my-thing 42}}

Fails to load gen-classed class with pf4j from uberjar

Tue, 26 Jan 2021 16:23:57 +0000

The problem here might be more related to the pf4j default classloader but still:

I have a clojure plugin generating a class

(gen-class
 :name myplugin.SomeExtension
 :implements [plugin.SomeExtensionPoint]
 :prefix "-"
 :impl-ns my-plugin.some-extension)

The plugin jar is loaded in my clojure application using pf4j. When it is compiled with lein jar the class loads (but then I naturally have to put any plugin dependencies in the apps project.clj). When compiled with lein uberjar it fails with:

 Execution error (IllegalStateException) at myplugin.SomeExtension/<clinit> (REPL:-1).
; Attempting to call unbound fn: #'clojure.core/refer

with top of call stack

jdk.internal.reflect.NativeConstructorAccessorImpl/newInstance0 (NativeConstructorAccessorImpl.java:-2)
jdk.internal.reflect.NativeConstructorAccessorImpl/newInstance (NativeConstructorAccessorImpl.java:62)
jdk.internal.reflect.DelegatingConstructorAccessorImpl/newInstance (DelegatingConstructorAccessorImpl.java:45)
java.lang.reflect.Constructor/newInstance (Constructor.java:490)
java.lang.Class/newInstance (Class.java:584)
org.pf4j.DefaultExtensionFactory/create (DefaultExtensionFactory.java:38)
org.pf4j.ExtensionWrapper/getExtension (ExtensionWrapper.java:37)
org.pf4j.AbstractPluginManager/getExtensions (AbstractPluginManager.java:971)

I've struggled a bit but I am unsure about exactly what happens here and how to solve it?
Any ideas are most welcome!

(and the uberjar profile uses {:aot :all :omit-source true})

Hide Warnings from Com.Google.Cloud.Translate

Tue, 26 Jan 2021 02:38:21 +0000

Howdy. I am using this excellent wrapper over google translate. https://github.com/billwinkler/google-translate

However, whenever I invoke
(gt/translate! ... :from "" :to "")
I get warnings printed to the console / REPL.
I would really like to not see these warnings:

WARNING: Ignoring Application Default Credentials GOOGLE_APPLICATION_CREDENTIALS: using explicit setting for API key instead.

I am relatively new to logging and understand the java side of things is a mess, is there any way I can prevent seeing these warnings in the REPL ?

-X args: pass in entire map + merge strategy

Fri, 15 Jan 2021 14:17:39 +0000

I would like to pass in an entire arg map to clojure -X and decide using a custom function how this should be merged with the default one from deps.edn. This could be a function in the :exec-fn alias, e.g. :exec-merge-args (and could default to merge or something based on merge-with).

My reason for this request is that passing in individual paths takes quite a lot of quoting on the command line for paths and strings. It would be less thinking and less error prone to just pass in one quoted map.

This is related to https://ask.clojure.org/index.php/10059/x-args-add-things-to-vector.
If I could describe how this should be merged using a custom function, adding things to a vector would be sufficiently solved as well.

-X args: add things to vector

Fri, 15 Jan 2021 14:14:07 +0000

How does one update an arg map for clojure -X like in the following:

{:some-tool {:scan-paths ["src"]}}

Say I want to add "test" to this. How does one achieve this on the command line?

Clojure Generation PDF blockchain

Mon, 27 Jul 2020 23:41:31 +0000

Hi guys, I'm going to start developing a project and I want you to recommend some technologies that I can use and be useful for my project.

Currently I have a system that generates PDF documents, but these documents do not have any type of security, what I want is: Generate PDF documents using blockchain and create a transactional query application for the generated documents

Can someone make a recommendation to start my project?

Thank you.!

Possibly revise s/merge behavior in spec.alpha2

Thu, 07 Nov 2019 17:31:28 +0000

The example below shows that you can get generated values out of an s/merge using mult-specs that don't make sense with the intended spec.

Looking at the implementation of the generator for s/merge each arg to s/merge gets generated individually, but it would be nice if they instead flowed through from right to left so things like multi-specs wouldn’t choose randomly from their dispatches.

  (s/def :ent/id string?)

  (defmulti ent-multi-id :ent/id)
  (defmethod ent-multi-id :default [_] (s/keys))

  (defn maybe-retag-fn [retag-k]
    (fn [gen-v dispatch-tag]
      (if (= dispatch-tag :default)
        gen-v
        (assoc gen-v retag-k dispatch-tag))))

  (s/def ::ent (s/merge (s/multi-spec ent-multi-id (maybe-retag-fn :ent/id))
                        (s/keys :req [:ent/id])))

  (gen/sample (s/gen ::ent) 5)
  ;; => ({:ent/id ""} {:ent/id "w"} {:ent/id ""} {:ent/id "66"} {:ent/id "63v"})

  (s/def :foo/id string?)

  (defmethod ent-multi-id "foo" [_]
    (s/keys :req [:foo/id]))

  (gen/sample (s/gen ::ent) 5)
  ;; => ({:foo/id "", :ent/id ""} {:foo/id "6", :ent/id "f"} {:foo/id "A", :ent/id "W"} {:foo/id "L", :ent/id "nd"} {:ent/id "H"})

Clojure Q&A - Questions without answers in Clojure

Possibly avoidable identity call to force instance method on Class literals

Syntax-quoted lists can return nil, differs from ClojureScript

Consider including a built-in wrapper around `java.net.http.HttpClient` in future versions of Clojure

Request: allow a user function to be specified as the target of clojure.main/report-error

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

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

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

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

clojure -X hangs with agent use

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

`(even? (range))` hangs

Associative destructuring with if-let

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

Teaching Old eval New Tricks

Tagged Literals Promise Extensibility

Towards a Solution

Is there a polished version of auto-agents?

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

Memory leak in seque via agents

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?

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

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

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

How to design testing library?

Links to EPL license are now broken

problem with Null exception in cl-format

Channel for real-time conversation on Freenode irc, visit: https://webchat.freenode.net/

Locals clearing issue with a type-hinted vs non-type-hinted letfn?

Performance improvements to creation of small vectors with TransientVector

Run a task parallely to delete tags

how to start a web server in dev mode in an interactive mode with hot reload and refresh

Syntax of sql files for luminus-migrations

Clojure and Clojurescript as options for an Electronic Health Record project

Protocol dispatch via interfaces is nondeterministic

(s/form (s/multi-spec ...)) returns a list with non-symbolic objects

Could we expose the data behind ranges?

Unable to run Clara Rules from Java

Should clojure.zip preserve metadata on zipper that is in end state?

Fails to load gen-classed class with pf4j from uberjar

Hide Warnings from Com.Google.Cloud.Translate

-X args: pass in entire map + merge strategy

-X args: add things to vector

Clojure Generation PDF blockchain

Possibly revise s/merge behavior in spec.alpha2

Teaching Old `eval` New Tricks

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