Clojure Q&A - Recent activity in ClojureScript

Edited: Missing protocol error will hang on infinite `(range)` input in ClojureScript but not Clojure

Fri, 03 Apr 2026 11:22:38 +0000

functions like transient, assoc, etc will throw helpful missing-protocol error when receiving invalid input but it will hang if it receives infinite (range).
this is related to issue below
https://ask.clojure.org/index.php/14578/even-range-hangs?show=14578#q14578

however, missing-protocol only hang in clojurescript but not clojure so I am wondering if this difference is intended.

example calls that should throws
- (transient (range))
- (assoc (range) :a 1)

TypedArrays don't implement ICounted in cljs

Thu, 05 Feb 2026 12:37:54 +0000

I just discovered that JS TypedArrays (Uint8Array et al) do not implement ICounted out of the box, even though it's trivial to make them do so. As a result count doesn't work on them; this is in contrast to Clojure where count works on arrays of primitives. Can/should this be added, or is the current behaviour intended?

(count (js/Uint8Array. [1 2 3]))
;; Execution error (Error) at (<cljs repl>:1).
;; No protocol method ICounted.-count defined for type object: 1,2,3
;=> :repl/exception!

(extend-protocol ICounted
 js/Uint8Array 
 (-count [this] (alength this)))
;=> #object [Function]

(count (js/Uint8Array. [1 2 3]))
;=> 3

Commented: Feature request: async/await support in CLJS

Tue, 20 Jan 2026 09:24:19 +0000

There is a patch for cljs now: https://clojure.atlassian.net/browse/CLJS-3470

Answered: false positive warning: "cljs.core/+, all arguments must be numbers"

Tue, 06 Jan 2026 20:07:06 +0000

The problem is the when. The inference mechanism isn't strong enough to narrow the return type (number|nil) if the type of the argument is known.

Commented: ClojureScript :preloads doesn't work with just cljs.main --repl

Sun, 28 Dec 2025 16:48:20 +0000

I created an issue here https://clojure.atlassian.net/browse/CLJS-3469. Have you done the Clojure CA? If so please attach the patch to the issue!

Commented: `(max "x" "y")` used to return "y", now it returns "x"

Mon, 22 Dec 2025 19:22:04 +0000

ok, thank you!

Answered: `derive [tag] [parent]` accepts non namespaced keyword/symbol as `tag` ?

Mon, 15 Dec 2025 20:54:55 +0000

Reading between the lines of this commit message, it seems like the intent was to relax the requirements on namespacing for private hierarchies (so, required for global but not for private).

Thus, I'm going to treat this as documentation issue in Clojure (presumably adding this constraint would break some existing code). Logged as https://clojure.atlassian.net/browse/CLJ-2934.

Not sure on CLJS.

Commented: Add requiring-resolve to ClojureScript

Wed, 10 Dec 2025 16:38:46 +0000

Hm well still, couldn't we have a REPL-only version, and/or an async runtime version?

Commented: How does `parents` work for JavaScript inheritance?

Wed, 26 Nov 2025 15:48:54 +0000

Great! Thank you for the answer and for the patch :)

Edited: Possible ClojureScript bug: corner case with regex literal compilation

Sun, 21 Sep 2025 04:30:33 +0000

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

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

This minimal unit test example demonstrates the issue:

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

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

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

Retagged: Bug in Clojurescript string/split with limit?

Fri, 18 Jul 2025 19:15:22 +0000

This seems like a bug to me? Using limit in clojure.string/split (in Clojurescript) gives the wrong result on a simple split.

;; NB Clojurescript
(clojure.string/split "a|b" #"|")
;=> ["a" "|" "b"]
(clojure.string/split "a|b" #"|" 3)
;=> ["" "" "a|b"]

Results should be the same?

Corresponding code in Javascript

"a|b".split(/|/)
;=> ['a', '|', 'b']
"a|b".split(/|/, 3)
;=> ['a', '|', 'b']

Commented: Is it possible to get ClojureScript hot reload in a Chrome Extension?

Wed, 25 Jun 2025 10:57:53 +0000

Okay, upon reflection I understand that the ClojureScript REPL depends on eval, and this isn’t something that content scripts support (for security reasons) -

https://developer.chrome.com/docs/extensions/develop/concepts/content-scripts

```js
const data = document.getElementById("json-data");
// WARNING! Might be evaluating an evil script!
const parsed = eval("(" + data + ")");
```

Answer selected: Cannot compile namespace including `+` in clojurescript

Wed, 21 May 2025 06:38:21 +0000

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

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

In Clojure, the following expression works fine:

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

But in Clojurescript, it returns nil.

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

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

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

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

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

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

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

Commented: Is cljs.test swallowing exceptions?

Fri, 18 Apr 2025 16:35:27 +0000

Thanks Eugene, great thoughts as usual. I amended my question with additional information based on your ideas.

Answered: Protocol function with placeholder _ arguments doesn't work as in Clojure

Mon, 17 Mar 2025 18:30:27 +0000

https://clojure.atlassian.net/browse/CLJS-3431
This issue was made in response

Answered: Source maps show the wrong row in ClojureScript

Thu, 06 Mar 2025 21:56:33 +0000

What optimization setting are we talking about here, :none?

Answer selected: ClojureScript: Destructuring two keys differing only on dash vs underscore doesn't work

Tue, 11 Feb 2025 14:37:12 +0000

I think this is just a bug, not a limitation - thanks for the report tracking here - https://clojure.atlassian.net/browse/CLJS-3426

Answered: How to get interactive programming back when using shadow-cljs with dynamically rendered html

Wed, 20 Nov 2024 20:09:20 +0000

Are you talking about stoping autoreload? https://shadow-cljs.github.io/docs/UsersGuide.html#_config

Answered: For shadow-cljs, how do you get humane-test-output working for the `:browser-test` build target?

Sat, 02 Nov 2024 08:48:07 +0000

shadow-cljs currently uses cljs-test-display for :browser-test. This makes the UI slightly prettier.

cljs-test-display sets its own :reporter value when running the tests (see code).

As far as I can tell this then bypasses the overwritten :fail reporter created by humane-test-output here.

The problem is that cljs-test-display seems to be relying on that custom reporter to create its own UI, so replacing that bit will likely break the UI in some way.

I'm guessing you'd need to overwrite this bit and hook up humane-test-output into that. I'm not sure how feasible this is.

Commented: ClojureScript compiler does not transpile "es8" closure libraries

Thu, 22 Aug 2024 17:46:39 +0000

Did you submit a CA? I think after that you should be able to login and attach.

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

Sat, 06 Apr 2024 08:36:43 +0000

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

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

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

Mon, 18 Mar 2024 08:40:31 +0000

Interestingly, in Clojure, deftype refuses to compile, while defrecord allows this.

Answer selected: Var metadata leaves functions in non-evaluated state

Sat, 02 Mar 2024 22:13:32 +0000

It has nothing to do with macroexpansion. Metadata on vars in CLJS is not evaluated, that's it. Why exactly - I don't know. There's some discussion at https://clojure.atlassian.net/browse/CLJS-2390

Your example with vectors works because the function form is mentioned not in the metadata position of the def macro, so its evaluation happens in a regular way.

Answered: cljs.core/test does not work as the docstring describes

Tue, 27 Feb 2024 17:32:14 +0000

Thanks for the report - https://clojure.atlassian.net/browse/CLJS-3411

Answered: How does cljs require npm package

Sun, 25 Feb 2024 06:58:30 +0000

It seems cljs already fix this issue.

  :dependencies [[org.clojure/clojure "1.11.1"]
                 [org.clojure/clojurescript "1.11.132"]]

With those version, the following code works as expected:

(ns cljs-demo.core
  (:require [pdfjs]
            [puppeteer]))

(enable-console-print!)

(defn -main [& args]
  (println "Hello, World!" puppeteer)
  (println "Hello, World!" pdfjs)
  )

(set! *main-cli-fn* -main)

Commented: Support for js/BigInt

Mon, 12 Feb 2024 14:34:40 +0000

Thanks for answering.
Take this as an "upvote" for prioritizing more thought on BigInts in ClojureScript then :D

Commented: Incorrect deprecation warnings

Sun, 28 Jan 2024 17:23:06 +0000

Which might be related to this issue https://clojure.atlassian.net/browse/CLJS-2000

Answered: ClojureScript and the deprecation of Google Closure Library

Thu, 25 Jan 2024 01:50:34 +0000

See David Nolen's update here in the latest ClojureScript release: https://clojurescript.org/news/2024-01-24-release

Answer selected: Function with meta equality fails

Tue, 26 Dec 2023 18:38:46 +0000

The page also says "Two objects that differ only in metadata are equal" and "an object with different metadata is a different object."

Thus, equality is "impacted" where it relies on object identity. As is the case for compiled functions: (not= (fn []) (fn [])) regardless of metadata.

A clarification might be in order.

Closed: MUI Select - add deselect function

Wed, 13 Dec 2023 13:54:09 +0000

(defn- menu-item
  [value-fn label-fn state lang index item]
(let [value (value-fn item)
    label (label-fn item lang)]
^{:key index}
[:> m/MenuItem {:value   value
                :data-cy (-> (str value) (str/lower-case) (str/replace " " "-") (str "-menu-item"))}
 [:> m/Checkbox {:checked (= (value-fn state) value)}]
 [:> m/Typography {} label]
 ]))

(defn select
  [{:keys [data state-fn disabled? label value-fn label-fn data-cy variant]}]
  (let [rf-lang   (rf/subscribe [:current-language])
        label-fn1 (or label-fn (fn [item lang] (value-fn item)))]
    (fn [{:keys [data state-fn disabled? label value-fn data-cy variant]}]
      (let [lang  @rf-lang
            state (state-fn)
            props (cond->
                    {:select      true
                     :full-width  true
                     :SelectProps {:MenuProps    {:getContentAnchorEl nil}
                                   :render-value (fn [items]
                                               (if label-fn
                                                 (label-fn state lang)
                                                 (map identity items)))
                               :data-cy      data-cy}
                 :value       (or (value-fn state) "")
                 :on-change   (fn [e]
                                (let [selected (.. e -target -value)]
                                  (state-fn (first (filter #(= selected (value-fn %)) data)))))
                 :label       (i18n/translation label lang)
                 :disabled    disabled?}
                variant (assoc :variant variant))]
    [:> m/TextField props (map-indexed (partial menu-item value-fn label-fn1 state lang) data)]))))

I have the following piece of code to create a dropdown list with items that have a checkbox next to them. The problem is that the checkbox cannot be removed. When the user clicks on an already selected checkbox, nothing happens. And in this case, it should become deselect.

Answered: Why doesn't `type` in CLJS check `:type` on its arguments meta like CLJ does?

Wed, 13 Dec 2023 10:00:57 +0000

Hi Colin,

Was wondering the same thing and I found some discussions in the slack channel:

https://clojurians.slack.com/archives/C07UQ678E/p1593166172290700

https://clojurians.slack.com/archives/C07UQ678E/p1610190759145100

TLDR:
Yeah, bummer. No one wants inconsistencies.
At this point in time, too scary to change :)
+ Not enough incentive (use-cases) identified.

Answered: ClojureScript doesn't respect the provided :line and :column meta for functions

Thu, 16 Nov 2023 16:57:26 +0000

Please create an issue + patch in JIRA, thanks :)

Commented: sorted-map with heterogeneous keys crashes on lookup

Wed, 25 Oct 2023 23:05:39 +0000

> It’s a huge challenge trying to build a consistent, excellent language that lives in a vast ecosystem with a history of its own and different philosophies.

Couldn’t agree more, it’s often challenging even keeping consistency between two systems that one fully owns The fact that the Clojure has managed to make a consistent language on top of two (or more) ecosystems with such a long legacy is a testament to the deep thinking that has gone into it, and I appreciate it

Commented: clojure.pprint/pprint prints superfluous spaces before newlines

Sat, 21 Oct 2023 09:25:06 +0000

I stand corrected :)

Commented: Can't add #inst values to var metadata. Error: Not supported: class java.time.Instant

Sun, 08 Oct 2023 18:48:33 +0000

I think putting #inst in source code is a mistake https://widdindustries.com/blog/what-is-inst.html

Commented: "not a relative path" bug

Thu, 28 Sep 2023 09:41:20 +0000

A colleague just ran into this again. It prompted me to recheck if the above repro still works. It does:

[Figwheel] Failed to compile build tests in 28.338 seconds.
[Figwheel:WARNING] Compile Exception: /src/github.com/solita/mnt-teet/app/frontend/target/public/cljs-out/tests/l/events/eventtype.js is not a relative path
Execution error (IllegalArgumentException) at cljs.closure/write-javascript (closure.clj:2031).
/src/github.com/solita/mnt-teet/app/frontend/target/public/cljs-out/tests/l/events/eventtype.js is not a relative path

Full report at:
/tmp/clojure-594316621683314904.edn

Answer selected: Clojurescript issue in 1.11.121 and master when compiling

Wed, 13 Sep 2023 16:45:33 +0000

Thanks reverted - to be honest no longer sure of the rationale of the original change - tracking again in the original issue - https://clojure.atlassian.net/browse/CLJS-3383

Answer selected: How to transform js/Error to a clojurescript map?

Tue, 22 Aug 2023 17:35:34 +0000

js->clj only transforms regular JavaScript Object and Arrays. Error is a sub-type, so it isn't converted. You can implement the cljs.core/IEncodeClojure protocol in theory, so that it does get converted. It is not done by default since the stack information in js/Error is not standardized in any way, so each JS runtime more or less does it own thing. Handling all of them is kinda tedius and would bloat the code too much for very rare use cases.

There is a cljs.core/Throwable->map fn coming, but I believe that is unreleased as of yet. You could just copy it until then.

Retagged: Setting `warning-handlers` in a config file fails with "Wrong number of args (3) passed to: clojure.lang.Symbol"

Tue, 22 Aug 2023 00:20:56 +0000

This config:

{:main             warning-handlers
 :warning-handlers [cljs.analyzer/default-warning-handler]}

Which set :warning-handlers to the default as listed in https://clojurescript.org/reference/compiler-options#warning-handlers

Compiled using:

clj -M --main cljs.main --compile-opts compile.edn --compile

Fails with:

   {:type clojure.lang.ExceptionInfo,
    :message
    "Wrong number of args (3) passed to: clojure.lang.Symbol at line 1 /Users/danie/matter/source/cljs-config/src/warning_handlers.cljs",
    :data
    {:file
     #object[java.io.File 0x27f8f1cc "/Users/danie/matter/source/cljs-config/src/warning_handlers.cljs"],
     :line 1,
     :column 1,
     :tag :cljs/analysis-error},
    :at [cljs.analyzer$error invokeStatic "analyzer.cljc" 780]}

Full repro here: https://github.com/danieroux/cljs-config

Answered: cljs range fn does odd things with nil, is this a bug?

Sun, 16 Jul 2023 18:00:58 +0000

The behavior of non-numeric args passed to range is undefined.

Retagged: Should documentation be added to explain the default browser console representation of CLJS collections and seqs?

Tue, 30 May 2023 17:08:22 +0000

Using console.log on a CLJS collection or sequence returns an internal representation of the object that looks like `Object { meta: null, cnt: 3, shift: 5, root: {…}, tail: (3) […], __hash: null, "cljs$lang$protocol_mask$partition0$": 167666463, "cljs$lang$protocol_mask$partition1$": 139268 }`. This seems like an easy pitfall for a beginner since console.log is a standard debugging tool for JS developers. Referring users to something like binaryage/devtools or any of the built-in functions for converting CLJS types to JS types might be helpful.

Retagged: `specify!` and `set!` silently fail if object is not extensible

Tue, 30 May 2023 14:42:23 +0000

specify! implicitly relies on the provided object to be extensible so that protocol implementations can be provided. Here is a quick demonstration from a REPL.

cljs.user> (def obj #js {:current nil})
[#js {:current nil}]
cljs.user> (js/Object.preventExtensions obj)
{"current" nil}
cljs.user> (specify! obj
              IDeref
              (-deref [^js this] (.-current this)))
{"current" nil}

Note that reify does not document this requirement either. This leads to confusing situations where non-extensible objects returned by JavaScript libraries (e.g. React) are unable to be extended and the user has little clue why.

Similarly, set! silently fails when objects are not extensible.

cljs.user> (set! (.-foo obj) "bar")
"bar"
cljs.user> obj
{"current" nil}

goog.object/set is able to detect this and throw an error.

cljs.user> (goog.object/set obj "foo" "bar")    
Execution error (TypeError) at (<cljs repl>:1).
Cannot add property foo, object is not extensible
:repl/exception!

Answered: cljs compile warning: JavaScript file found on classpath for library `...`, but does not contain a corresponding...

Thu, 18 May 2023 15:29:27 +0000

This was not an issue with cljs at all - sorry for the noise.

For future generations of searchers, the change was in the google-closure-library, "goog.net.cookies" was deprecated and removed in favor of "goog.net.Cookies" and a more enterprise-y factory singleton getter initialization.

Link: https://github.com/google/closure-library/releases/tag/v20220301

When cljs does upgrade to newer closure library versions uses of this will break.

Thanks to everyone for your help tracking this down.

Commented: Custom printing method for records

Mon, 08 May 2023 09:31:23 +0000

That's kinda sad. In my case it's more of a repl and DSL thing, so I guess I'll be writing a printing protocol and extending it to everything. Thanks.

Comment edited: Why does this work in CLJS but doesn't in JVM Clojure?

Fri, 28 Apr 2023 08:15:22 +0000

> Undefined behavior is prescribed to be unpredictable by language

If you read more discussions with the core team, undocumented is usually treated as undefined. That's now how they view things, at least under my interpretation and given my memory.
E.g. see this good comment by Sean Corfield: https://groups.google.com/g/clojure/c/yMHHHuK44pE/m/LeBhqdq6BQAJ
Or this by Alex Miller that explicitly talks about UB in the context of a lack of documentation for something particular: https://groups.google.com/g/clojure/c/VwA2Un2NMxc/m/tptww3xZBwAJ
Or this: https://groups.google.com/g/clojure/c/HtK4pqsr--8/m/KbWvq8CFCQAJ
And many, many others, all around the media.

> unspecified behavior

Clojure leaves a *lot* unspecified. The language itself doesn't have any specification or a standard, only docs (that don't document every single thing that exists), some spec definitions, and the reference implementation. It has been explicitly stated before that specifying everything is not a goal.

As an example calling `keys` or `vals` or iterating over the same map object will return items in the same order. But a different map object that is equal to the first one might return them in different order. And a map in CLJS will almost definitely return values in an order different from the one in CLJ.

> If that's a bug in the compiler it may be within protocol implementation which can be a serious problem.

That would be a different discussion, if that were the case.

Answered: Questions about cljs.core/prefers* (maybe bugs?)

Mon, 17 Apr 2023 21:29:21 +0000

I suspect that code probably derives from the Clojure code in MultiFn, which had that bug with the hierarchy (and was fixed in 1.11 - see https://clojure.atlassian.net/browse/CLJ-2234 ).

Answered: Firefox addon written in cljs can't pass Mozilla's review

Thu, 30 Mar 2023 14:24:02 +0000

A couple of years ago, I had a similar question (only in my case it was for better caching) and at least back then the answer was "no". But you might try to build with the optimizations set to simple. It also does some renaming but I think it's stable. If that doesn't work, whitespace should.

Answered: Docstring of with-redefs should mention usage of ^:dynamic in production

Tue, 14 Mar 2023 13:42:57 +0000

Just a side-note:

In JVM Clojure you ^:redef metadata is sufficient. See also the docs on direct linking:

https://clojure.org/reference/compilation#directlinking

Answered: Feature request: option to demunge keys in `js->clj` function

Sun, 05 Feb 2023 11:08:35 +0000

Wouldn't it be more flexible if keywordize-keys received a function instead of a boolean, so you can do whatever you want, including demunging?