Clojure Q&A - Recent questions in ClojureScript

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

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

Tue, 06 Jan 2026 16:51:22 +0000

The inc function below will never receive a nil, but falsely warns that it might:

clj -Sdeps '{:deps {org.clojure/clojurescript {:mvn/version "1.12.134"}}}' -M -m cljs.main -re node
ClojureScript 1.12.134

cljs.user=> (some-> 1 (#(when (pos? %) %)) inc)
WARNING: cljs.core/+, all arguments must be numbers, got [#{nil clj-nil} number] instead at line 1 <cljs repl>
2

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

Wed, 24 Dec 2025 15:13:56 +0000

Running cljs.main with just --repl doesn't preload whatever is on :preloads.

Given that the quickest way of trying ClojureScript is by running a command like :

clj -Sdeps '{:deps {org.clojure/clojurescript {:mvn/version "1.12.134"}}}}' -M -m cljs.main --repl

it would be great (and I think expected) to be able to run a repl with some dev tooling, like :

clj -Sdeps '{:deps {org.clojure/clojurescript {:mvn/version "1.12.134"} binaryage/devtools {:mvn/version "1.0.7"}}}}' -M -m cljs.main -co '{:preloads [devtools.preload]}' --repl

but it doesn't work.

It reads the file (it complains if you misspell the preload namespace) but then nothing gets loaded.

The problem seems to be related to ClojureScript not compiling the preload namespace when you run with just --repl

If you create a small single file project (like on the start guide) and then do :

clj -Sdeps '{:deps {org.clojure/clojurescript {:mvn/version "1.12.134"} binaryage/devtools {:mvn/version "1.0.7"}}}}' -M -m cljs.main -co '{:preloads [devtools.preload]}' --compile hello-world.core --repl

it works.
After the compile generates the out folder you can run just with --repl and the preload will work.

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

Mon, 22 Dec 2025 13:45:04 +0000

Hello!

With cljs 1.12.42:

cljs.user=> (max "x" "y")
"y"
cljs.user=>

With cljs 1.12.134:

cljs.user=> (max "x" "y")
"x"
cljs.user=>

Probably related to CLJS-3425 and this commit which added NaN checks:

(defn ^number max
  "Returns the greatest of the nums."
  ([x] x)
  ([x y]
   (cond
     (NaN? x) x
     (NaN? y) y
     (> x y) x
     :else y))
  ([x y & more]
   (reduce max (cljs.core/max x y) more)))

But:

cljs.user=> (NaN? "x")
true
cljs.user=>

Hence the result.

Not sure what the expected result should be since min/max are only supposed to work with numbers but current behavior is surprising.

How does `parents` work for JavaScript inheritance?

Sun, 23 Nov 2025 14:28:23 +0000

Hello

In Clojure, I can do:

(parents String)
; #{java.lang.constant.ConstantDesc java.lang.Object java.lang.CharSequence java.io.Serializable java.lang.constant.Constable java.lang.Comparable}

But in ClojureScript:

(parents js/String)
; nil

ClojureScript's parents doc does mention "JavaScript type inheritance":

Returns the immediate parents of tag, either via a JavaScript type
inheritance relationship or a relationship established via derive. h
must be a hierarchy obtained from make-hierarchy, if not supplied
defaults to the global hierarchy

Is there something wrong with the syntax I used?

Is parents really supposed to work with JavaScript inheritance on ClojureScript?

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

Wed, 19 Nov 2025 21:23:15 +0000

Hello

derive's doc says:

Establishes a parent/child relationship between parent and
tag. Parent must be a namespace-qualified symbol or keyword and
child can be either a namespace-qualified symbol or keyword or a
class.

But in practice, ClojureScript accepts non-namespaced tag:

(derive :a ::b)
; nil
(isa? :a ::b)
; true

Clojure throws.

Is ClojureScript behavior expected or a bug?

Same question for the derive [h tag parent] form, which seems to accept non-namespaced keyword/symbol for both tag and parent, this time on both Clojure and ClojureScript:

(derive (make-hierarchy) :a :b)
; {:parents {:a #{:b}}, :ancestors {:a #{:b}}, :descendants {:b #{:a}}}

Possible ClojureScript bug: corner case with regex literal compilation

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

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

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

This minimal unit test example demonstrates the issue:

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

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

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

Cannot compile namespace including `+` in clojurescript

Tue, 20 May 2025 10:12:48 +0000

Trying to compile any namespace including + fails in clojurescript

e.g.:

(ns test+.core)

(println "Hello, World!")

compiled with clojurescript "1.12.42"

clj -M --main cljs.main --compile test+.core

results in

 `Namespace test+.core does not exist.`

Trying to include the namespace from another gives:

Unexpected error (ExceptionInfo) compiling at (REPL:1).
No such namespace: test+.core, could not locate test_PLUS_/core.cljs, test_PLUS_/core.cljc, or JavaScript source providing "test+.core" (Please check that namespaces with dashes use underscores in the ClojureScript file name) in file /home/sigvesn/clojure/cljs-test/src/other.cljs

Note that it is possible to compile the namespace from regular clojure.

This is relevant because the clojure walk library uses + in the namespace

Repo with code to reproduce

Bug in Clojurescript string/split with limit?

Wed, 23 Apr 2025 12:03:38 +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']

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.

Is cljs.test swallowing exceptions?

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

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

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

Check this out:

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

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

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

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

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

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

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

Thanks so much for your time and consideration.

Edit:

Eugene makes an interesting point in the comments.

There is a similar difference in exception/error printing:

In cljs:

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

In clj:

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

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

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

While cljs does not:

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

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

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

Mon, 17 Mar 2025 14:58:32 +0000

A protocol like below will work in Clojure without issue, but in ClojureScript the _'s will apparently (quietly) override each other left to right.

(defprotocol Linkable
  (-href [_ _ _]))

Even if the extend-protocol has unique names for the args, the dispatch seems to happen on the last argument.

Repro at https://github.com/valerauko/proto-repro/commit/a8ad51a225ed44ed134b28a18cc83d272d0d8321

Using distinct argument names in the defprotocol solves the issue. I think if it doesn't / can't work like in JVM Clojure it should warn about this issue.

Source maps show the wrong row in ClojureScript

Wed, 05 Mar 2025 02:52:12 +0000

When some error occurs in ClojureScript, the source map usually shows the line above the actual error, but sometimes it's even worse. An example is on my own plug-in Lazuli, where using Reagent with the newer React causes a very weird source map, as following GIF:

The stracktrace shows:

lazuli$connections$conn_view            @ connections.cljs:64
(anonymous)	                            @ connections.cljs:199
lazuli$connections$connect_nrepl_BANG_  @	connections.cljs:195

But the correct lines are 63, and 197, with 195 being probably the only correct line in this

Is there any way to configure this to be correct?

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

Mon, 03 Feb 2025 16:09:41 +0000

When i try to destructure a key, supporting both kebab and snake case I run in to trouble:

Sometimes both symbols pick up the same value:

(let [{:keys [foo-bar foo_bar] :as m} {:foo_bar 42}]
  [foo-bar (:foo-bar m) foo_bar (:foo_bar m)])
;;=> [42 nil 42 42]

Other times one symbol overshadows the other one:

(let [{:keys [foo-bar foo_bar
              a b c d e f g] :as m} {:foo_bar 42}]
  [foo-bar (:foo-bar m) foo_bar (:foo_bar m)])
;;=> [nil nil nil 42]

At least that's what I think is going on there: foo-bar doesn't exist and gets the value nil, overshadowing the symbol foo_bar for which the value exists.

This is supposedly a known limitation in ClojureScript, but I couldn't find it in the issue tracker. Nor does it seem like ChatGPT knows about it. Maybe it helps a bit to have it visible here for bots and humans alike.

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

Fri, 15 Nov 2024 12:04:42 +0000

Hi,

I am generating html dynamically on the server with hiccup. I am using the include-js macro to add the javascript that has been compiled from clojurescript to the hiccup template. The shadow-cljs cli just watches the clojurescript and just compiles the javascript.

But when I use this approach I lose all the interactive programming that I have if I am using shadow-cljs with a statically rendered html file.

Is it possible to get interactive programming with clojurescript where one evaluates expressions on the fly with a repl when using shadow-cljs while generating the html dynamically.

I am assuming shadow-cljs is adding some interactive javascript to the statically rendered file that will make it possible to get the interactivity one wishes to get. Is it possible to add that missing piece to html that one is generating themselves?

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

Fri, 01 Nov 2024 17:43:29 +0000

For the :node-test build target it was extremely simple to set up humane-test-output, but I am having difficulty with the :browser-test target.

I am curious if anyone else has it working and can give pointers?

ClojureScript compiler does not transpile "es8" closure libraries

Tue, 20 Aug 2024 17:42:31 +0000

The ClojureScript compiler determines the type of the Closure library in the transpile function. However, :es8is not implemented.

I have a fix for this, when a bug number has been assigned.

Thanks,
Hadil

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

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

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

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

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

Sat, 16 Mar 2024 14:17:48 +0000

I've been working with Chrome Extensions for some time and it would be amazing to get ClojureScript hot reloading capabilities there.

I tried Thomas Heller example shadow-cljs project for Chrome Extensions and some other stuff that I documented in a minimum example repo, but with no success.

In summary, seems like the Chrome Extensions' v3 manifest prohibits eval, which means we are out of luck?

Thanks!

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

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

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

This:

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

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

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

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

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

Var metadata leaves functions in non-evaluated state

Sat, 02 Mar 2024 21:28:11 +0000

When storing a function in a var's metadata, is behaves counterintuitively (at least to me).
Is this a bug or the intended behavior? If the latter, what is the reasoning?

Given the following def:

(def
  ^{:fn-in-meta (fn [a b] (+ a b))}
  my-var
  :value)

In Clojure things work as expected, one can get the function out of the metadata and it is still a regular function:

  ; clj
(-> #'my-var
    meta
    :fn-in-meta)
;; => #function[myns/fn--27244]

; clj
(-> #'my-var
    meta
    :fn-in-meta
    type)
;; => myns$fn__27244

In clojurescript however, doing the same seems to result in some semi-compiled state that looks similar to a macroexpansion.

 ; cljs
(-> #'my-var
    meta
    :fn-in-meta)
;; => (fn [a b] (+ a b))

; cljs
(-> #'my-var
    meta
    :fn-in-meta
    type)
;; => cljs.core/List

Finally, note that adding metadata to another object, such as a vector behaves normally in noth languages.

 ; cljs
(->> {:fn-in-meta (fn [a b] (+ a b))}
     (with-meta [])
     meta
     :fn-in-meta
     type)
;; => #object[Function]


; clj
(->> {:fn-in-meta (fn [a b] (+ a b))}
     (with-meta [])
     meta
     :fn-in-meta
     type)
;; => myns$eval27282$fn__27283

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

Tue, 27 Feb 2024 12:33:17 +0000

cljs.core/test does not work according to its docstring description.

The definition of cljs.core/test is

(defn test
  "test [v] finds fn at key :test in var metadata and calls it,
  presuming failure will throw exception"
  [v]
  (let [f (.-cljs$lang$test v)]
    (if f
      (do (f) :ok)
      :no-test)))

It's intended use, as far as I understand it, is as such (example copied from the documented Clojure version of the same function at ClojureDocs, https://clojuredocs.org/clojure.core/test#example-542692cac026201cdc326b8a ):

(defn my-function
  "this function adds two numbers"
  {:test #(do
            (assert (= (my-function 2 3) 5))
            (assert (= (my-function 4 4) 8)))}
  ([x y] (+ x y)))

(test #'my-function)  ;equal to (test (var my-function))
=> :ok

So, cljs.core/test enables functions to self-document their capabilities via tests made available in metadata under the :test key.

However, repeating the above in a CLJS environment yields a different result:

(defn my-function
  "this function adds two numbers"
  {:test #(do
            (assert (= (my-function 2 3) 5))
            (assert (= (my-function 4 4) 8)))}
  ([x y] (+ x y)))

(test #'my-function)
=> :no-test

The interesting thing is that, given that I evalated the above in a CLJS REPL, the metadata is available, as far as I can tell:

(meta #'my-function)
=>
{:ns cljs.user,
 :name my-function,
 :file "<cljs repl>",
 :end-column 18,
 :source "my-function",
 :column 1,
 :line 1,
 :end-line 1,
 :arglists ([x y]),
 :doc "this function adds two numbers", 
 :test #object[Function]}

This can be made even clearer by substituting the rather opaque function for a keyword:

(defn my-function
  "this function adds two numbers"
  {:test :just-a-keyword}
  ([x y] (+ x y)))

(meta #'my-function)
=>
{:ns cljs.user,
 :name my-function,
 :file "<cljs repl>",
 :end-column 18,
 :source "my-function",
 :column 1,
 :line 1,
 :end-line 1,
 :arglists ([x y]),
 :doc "this function adds two numbers", 
 :test :just-a-keyword}

I spoke to @theller and @hiredman about this on the Clojurians Slack, and they speculated that cljs.core/test has been repurposed to execute the body of deftests, since the two pieces seem to fit together. Observe:

(require '[cljs.test :as test])
(test/deftest foo (test/is (= 1 2)))
=> #'cljs.user/foo

(test foo)
FAIL in () (<NO_SOURCE_FILE>:1:28)
expected: (= 1 2)
  actual: (not (= 1 2))

:ok

The deftest body is executed and the keyword :ok is returned (regardless of the is result), as can also be gathered from reading definition of cljs.core/test.

If it is true that cljs.core/test has been repurposed in this manner, then two things are also true:

A) If it ever were the intent that cljs.core/test should enable testing :test assertions for defns, that no longer holds.
B) The docstring of cljs.core/test is somewhat misleading.

The first bit of the docstring, "test [v] finds fn at key :test in var metadata and calls it", may be technically correct, but mentions no connection with deftest, and therefore somewhat unhelpful.

The second bit of the docstring, ", presuming failure will throw exception", is certainly not correct when used for deftest - the cljs.test/is macro, which I think is fair to say that most deftests use, catches exceptions and reports instead. I think the original intent is that the execption is thrown, so :ok is not returned, but in this context, that construct fails.

The docstring seems to be a carbon copy of the Clojure version, so possibly, it warrants an update. Or maybe cljs.core/test is simply unused and redundant at this point?

Support for js/BigInt

Fri, 09 Feb 2024 13:32:21 +0000

Native support for BigInt in JavaScript has been around since 2020. (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt)

Any chance of support for this in ClojureScript any time soon?

Would be nice to be able to use this as a number in numeric ops and as a key in hash maps.
Also, cljs.core could be extended with functions like bigint and integer? from clojure.core.

BigInts would bring clojurescript one step closer to supporting Ratios.

Incorrect deprecation warnings

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

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

deps.edn
`clojure

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

src/hello_world/core.cljs
`clojure

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

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

`
`clojure

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

ClojureScript and the deprecation of Google Closure Library

Fri, 12 Jan 2024 16:33:30 +0000

Google announced recently that they will be sunsetting the Closure Library (not Closure itself).

Does this impact ClojureScript in any meaningful way?

Thanks!

MUI Select - add deselect function

Wed, 13 Dec 2023 11:43:41 +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.

sorted-map with heterogeneous keys crashes on lookup

Tue, 24 Oct 2023 12:43:26 +0000

Hello,
I encountered some odd behavior with sorted-map which to me looks like a bug or a lack of documentation:

Specifically, when creating a sorted map with keys of different types like so: (sorted-map :k1 :v1 "k2" :v2) then lookup like so (:k1 (sorted-map :k1 :v1 "k2" :v2)) produces the exception: Cannot compare k2 to :k1. This seems due to the use of compare in the sorted-map implementation.

While the preferable (to me) course of action would be to fully support heterogeneous keys, It seems reasonable to require that the keys of a sorted-map are comparable, but in my opinion this should be stated in the docs.

Even if that were to be a requirement, it seems more inline with Clojure's general design spirit to return nil upon such a lookup, rather than throw an exception. It would make more sense to me to throw an exception the moment that a key is added which is not comparable to other keys already in the map. What do you think?

Cheers,
Simon

clojure.pprint/pprint prints superfluous spaces before newlines

Thu, 19 Oct 2023 20:04:51 +0000

Repro:

λ clj -Srepro -Sdeps '{:deps {org.clojure/clojurescript {:mvn/version "1.11.54"}}}}' -M -m cljs.main --repl-env node
ClojureScript 1.11.54
cljs.user=> (require '[clojure.pprint :refer [pprint *print-right-margin*]])
nil
cljs.user=> (prn (with-out-str (binding [*print-right-margin* 20] (pprint {:a 1 :b 2 :c 3 :d 4}))))
"{:a 1,\n :b 2, \n :c 3, \n :d 4}\n"
nil

Note the spaces before the newlines after :b 2 and :c 3.

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

Sat, 07 Oct 2023 19:28:05 +0000

I wasn't able to add #inst values to var metadata. Compilation failed to Not supported: class java.time.Instant error

Steps to reproduce:

$ mkdir src
$ echo '(ns core) (def ^{:time #inst "2023-10-07"} foo :foo)' > src/core.cljs
$ clj -Sdeps '{:deps {org.clojure/clojurescript {:mvn/version "1.11.60"}}}' -M --main cljs.main --compile core

Expected: Compilation is successful

Actual:

Unexpected error compiling at (REPL:1).
Not supported: class java.time.Instant

Full report at:
/var/folders/0p/vtdv4p053pd6gkx8d5p98h000000gn/T/clojure-15941611179751768055.edn

Analysis:

CLJS-3291 changed the #inst reader to produce java.time.Instant instead of java.util.Date. The analysis cache transit writer is failing to write java.time.Instant because it only knows how to serialize java.util.Date.

Workaround:

(def foo :foo)
(alter-meta #'foo assoc :time #inst "2023-10-07")

Full report:

{:clojure.main/message
 "Unexpected error compiling at (REPL:1).\nNot supported: class java.time.Instant\n",
 :clojure.main/triage
 {:file
  #object[java.io.File 0x608f79a8 "/Users/mikko/Documents/Projects/sharetribe/instant-cljs2/src/core.cljs"],
  :clojure.error/phase :compilation,
  :clojure.error/class java.lang.Exception,
  :clojure.error/cause "Not supported: class java.time.Instant"},
 :clojure.main/trace
 {:via
  [{:type clojure.lang.ExceptionInfo,
    :message
    "failed compiling file:/Users/mikko/Documents/Projects/sharetribe/instant-cljs2/src/core.cljs",
    :data
    {:file
     #object[java.io.File 0x608f79a8 "/Users/mikko/Documents/Projects/sharetribe/instant-cljs2/src/core.cljs"],
     :clojure.error/phase :compilation},
    :at
    [cljs.compiler$compile_file$fn__4809 invoke "compiler.cljc" 1768]}
   {:type java.lang.RuntimeException,
    :message
    "java.lang.Exception: Not supported: class java.time.Instant",
    :at
    [com.cognitect.transit.impl.WriterFactory$1
     write
     "WriterFactory.java"
     65]}
   {:type java.lang.Exception,
    :message "Not supported: class java.time.Instant",
    :at
    [com.cognitect.transit.impl.AbstractEmitter
     marshal
     "AbstractEmitter.java"
     195]}],
  :trace
  [[com.cognitect.transit.impl.AbstractEmitter
    marshal
    "AbstractEmitter.java"
    195]
   [com.cognitect.transit.impl.JsonEmitter
    emitMap
    "JsonEmitter.java"
    171]
   [com.cognitect.transit.impl.AbstractEmitter
    emitMap
    "AbstractEmitter.java"
    86]
   [com.cognitect.transit.impl.AbstractEmitter
    marshal
    "AbstractEmitter.java"
    185]
   [com.cognitect.transit.impl.JsonEmitter
    emitMap
    "JsonEmitter.java"
    171]
   [com.cognitect.transit.impl.AbstractEmitter
    emitMap
    "AbstractEmitter.java"
    86]
   [com.cognitect.transit.impl.AbstractEmitter
    marshal
    "AbstractEmitter.java"
    185]
   [com.cognitect.transit.impl.JsonEmitter
    emitMap
    "JsonEmitter.java"
    171]
   [com.cognitect.transit.impl.AbstractEmitter
    emitMap
    "AbstractEmitter.java"
    86]
   [com.cognitect.transit.impl.AbstractEmitter
    marshal
    "AbstractEmitter.java"
    185]
   [com.cognitect.transit.impl.JsonEmitter
    emitMap
    "JsonEmitter.java"
    171]
   [com.cognitect.transit.impl.AbstractEmitter
    emitMap
    "AbstractEmitter.java"
    86]
   [com.cognitect.transit.impl.AbstractEmitter
    marshal
    "AbstractEmitter.java"
    185]
   [com.cognitect.transit.impl.AbstractEmitter
    marshalTop
    "AbstractEmitter.java"
    212]
   [com.cognitect.transit.impl.JsonEmitter emit "JsonEmitter.java" 41]
   [com.cognitect.transit.impl.WriterFactory$1
    write
    "WriterFactory.java"
    62]
   [cljs.vendor.cognitect.transit$write invokeStatic "transit.clj" 171]
   [cljs.vendor.cognitect.transit$write invoke "transit.clj" 168]
   [cljs.analyzer$write_analysis_cache$fn__3960
    invoke
    "analyzer.cljc"
    4771]
   [cljs.analyzer$write_analysis_cache
    invokeStatic
    "analyzer.cljc"
    4770]
   [cljs.analyzer$write_analysis_cache invoke "analyzer.cljc" 4757]
   [cljs.compiler$emit_source invokeStatic "compiler.cljc" 1642]
   [cljs.compiler$emit_source invoke "compiler.cljc" 1557]
   [cljs.compiler$compile_file_STAR_$fn__4778
    invoke
    "compiler.cljc"
    1671]
   [cljs.compiler$with_core_cljs invokeStatic "compiler.cljc" 1477]
   [cljs.compiler$with_core_cljs invoke "compiler.cljc" 1466]
   [cljs.compiler$compile_file_STAR_ invokeStatic "compiler.cljc" 1655]
   [cljs.compiler$compile_file_STAR_ invoke "compiler.cljc" 1648]
   [cljs.compiler$compile_file$fn__4809 invoke "compiler.cljc" 1753]
   [cljs.compiler$compile_file invokeStatic "compiler.cljc" 1728]
   [cljs.compiler$compile_file invoke "compiler.cljc" 1704]
   [cljs.closure$compile_file invokeStatic "closure.clj" 657]
   [cljs.closure$compile_file invoke "closure.clj" 635]
   [cljs.closure$fn__6472 invokeStatic "closure.clj" 731]
   [cljs.closure$fn__6472 invoke "closure.clj" 725]
   [cljs.closure$fn__6381$G__6374__6388 invoke "closure.clj" 553]
   [cljs.closure$compile_sources$iter__6598__6602$fn__6603
    invoke
    "closure.clj"
    1102]
   [clojure.lang.LazySeq sval "LazySeq.java" 42]
   [clojure.lang.LazySeq seq "LazySeq.java" 51]
   [clojure.lang.Cons next "Cons.java" 39]
   [clojure.lang.RT next "RT.java" 713]
   [clojure.core$next__5451 invokeStatic "core.clj" 64]
   [clojure.core$dorun invokeStatic "core.clj" 3143]
   [clojure.core$doall invokeStatic "core.clj" 3149]
   [clojure.core$doall invoke "core.clj" 3149]
   [cljs.closure$compile_sources invokeStatic "closure.clj" 1098]
   [cljs.closure$compile_sources invoke "closure.clj" 1087]
   [cljs.closure$build invokeStatic "closure.clj" 3200]
   [cljs.closure$build invoke "closure.clj" 3104]
   [cljs.build.api$build invokeStatic "api.clj" 231]
   [cljs.build.api$build invoke "api.clj" 212]
   [cljs.cli$default_compile invokeStatic "cli.clj" 530]
   [cljs.cli$default_compile invoke "cli.clj" 486]
   [cljs.cli$compile_opt invokeStatic "cli.clj" 542]
   [cljs.cli$compile_opt invoke "cli.clj" 540]
   [cljs.cli$main invokeStatic "cli.clj" 703]
   [cljs.cli$main doInvoke "cli.clj" 692]
   [clojure.lang.RestFn applyTo "RestFn.java" 139]
   [clojure.core$apply invokeStatic "core.clj" 669]
   [clojure.core$apply invoke "core.clj" 662]
   [cljs.main$_main invokeStatic "main.clj" 65]
   [cljs.main$_main doInvoke "main.clj" 56]
   [clojure.lang.RestFn applyTo "RestFn.java" 137]
   [clojure.lang.Var applyTo "Var.java" 705]
   [clojure.core$apply invokeStatic "core.clj" 667]
   [clojure.main$main_opt invokeStatic "main.clj" 514]
   [clojure.main$main_opt invoke "main.clj" 510]
   [clojure.main$main invokeStatic "main.clj" 664]
   [clojure.main$main doInvoke "main.clj" 616]
   [clojure.lang.RestFn applyTo "RestFn.java" 137]
   [clojure.lang.Var applyTo "Var.java" 705]
   [clojure.main main "main.java" 40]],
  :cause "Not supported: class java.time.Instant",
  :phase :compilation}}

Clojurescript issue in 1.11.121 and master when compiling

Tue, 12 Sep 2023 22:01:58 +0000

When compiling a file with :

clj -Sdeps '{:paths ["src"] :deps {org.clojure/clojurescript {:mvn/version "1.11.121"}}}' -M -m cljs.main -co '{:main org.foo.myscript}' --compile

the compilation will work fine, but if after that you run cljs.main --repl the browser repl will start, but evaluating forms on it will not work since evaluation will never finish.

This exact same commands work fine in 1.11.60.

After some debugging the issue seems to be caused by the current compiler never adding

document.write('<script>goog.require("clojure.browser.repl.preload");</script>');

to the resulting js file.

This is caused by :

https://github.com/clojure/clojurescript/blob/master/src/main/clojure/cljs/closure.clj#L2500-L2501

not adding the preload because :browser-repl isn't true.

The breaking change comes from this line:

https://github.com/clojure/clojurescript/blob/master/src/main/clojure/cljs/cli.clj#L498

which removes :browser-repl from the options because we are just compiling and there is no repl involved.

Looks like the behavior was explicitly changed by this commit :

https://github.com/clojure/clojurescript/commit/9c01d9b0a70ada1cb17cf3ce65ae93d76d0d3b08

Reverting the commit fixes the issue.

How to transform js/Error to a clojurescript map?

Mon, 21 Aug 2023 14:54:16 +0000

I'm getting a js/Error in my catch form of try/catch. I was doing some repl work to see what I can understand about js/Errors. What I don't understand is why (js->clj js-err) just returns the same js/Error object.

(def js-err (js/Error. "testing"))

js-err
;; => #object[Error Error: testing]
(js->clj js-err)
;; => #object[Error Error: testing]

evaluating js-err and (js->clj js-err) result in the same thing.

Here are the properties on js-err

(.getOwnPropertyNames js/Object js-err)
;; => #js["stack" "message"]

what I want or expect to happen:

(js->clj js-err)
;; => {:message "testing"
;;     :stack "blah\nblah"}

Could someone explain why js->clj doesn't give me the object data as a map, and is there a idiomatic way to accomplish turning that object into a map?

This is in the nodejs host

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

Sun, 20 Aug 2023 23:30:21 +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

Add requiring-resolve to ClojureScript

Tue, 25 Jul 2023 16:49:40 +0000

I'm not sure if there are any technical hurdles in adding requiring-resolve to ClojureScript, but it would be nice to have parity so REPL utilities can be written using it.

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

Sun, 23 Jul 2023 14:56:02 +0000

In CLJ a check for :type on the meta happens and then falls back to returning the constructor class. In CLJS only the constructor class is returned. It would be nice to have these consistent for usage with multimethods etc.

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

Fri, 14 Jul 2023 18:03:55 +0000

There is currently a difference between Clojure and ClojureScript in how the readers handle the provided :line and :column meta for forms.

In Clojure:

Clojure 1.11.1
user=> ^{:line 40} (defn foo [])
#'user/foo
user=> (-> #'foo meta :line)
40

while in ClojureScript:

ClojureScript 1.11.60
cljs.user=> ^{:line 40} (defn foo [])
#'cljs.user/foo
cljs.user=> (-> #'foo meta :line)
1

I think this is specially important in ClojureScript where there isn't a way of modifying vars meta.

Tooling like editors, when sending forms to the repl, can use this mechanism to add for example line information when they know it. Keeping this information is important since other stuff like clojure.repl/source depends on it, which currently breaks as soon as you eval a form from your editor.

I added a PR here with one possible solution https://github.com/clojure/clojurescript/pull/210

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

Thu, 13 Jul 2023 15:24:38 +0000

In Clojure, passing a nil as the first arg to range throws NPE, but in ClojureScript it doesn't and odd things can happen:

(range nil 0)
=> ()
(range nil 1)
=> (nil)
(range nil 2)
=> (nil 1)

What's worse is if you have the start and the step both being nil:

(range 0 0 0)
=> ()
(range nil 0 nil)
INTERNAL REPL ERROR: Got an unexpected reply from relay, check Inspect
Timeout while waiting for result.

This actually evaluates to an infinite seq of nils!

(take 10 (range nil 0 nil))
=> (nil nil nil nil nil nil nil nil nil nil)

:boom:

(also raised for discussion on the clojurians slack)

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

Wed, 17 May 2023 17:23:07 +0000

First, thanks for cljs, it's the best way to do frontends and it's one of the lifebloods of our business. We are super-grateful.

I am running some older code in a new project that has an updated cljs dependency and I am now getting an interesting compile warning:

WARNING: JavaScript file found on classpath for library `goog.net.cookies`, but does not contain a corresponding `goog.provide` declaration: jar:file:/home/harold/.m2/repository/org/clojure/google-closure-library/0.0-20211011-0726fdeb/google-closure-library-0.0-20211011-0726fdeb.jar!/goog/net/cookies.js

Everything seems to be working fine, but I am still interested in cleaning up this output.

I built a simple (two tiny file) project that reproduces the problem:
- https://github.com/harold/cookie-repro
- You can clone that and then do:

lein cljsprod

I did a 'bisect'-ish operation on the cljs deps in maven and found that the warning started to appear with version 1.10.891:
- https://github.com/clojure/clojurescript/blob/master/changes.md#110891
- Before that version, the warning is not seen

Wondering if others have seen this warning, or similar, and what, if any, steps would be good to take.

Thanks again for your time and consideration!

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

Thu, 11 May 2023 16:04:18 +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.

Custom printing method for records

Sun, 07 May 2023 08:10:49 +0000

In Clojure, this works:

(defmethod clojure.pprint/simple-dispatch
  my.ns.record
  [r] (print r))

But I can't find the equivalent in Cljs. With no success, I've tried:

(defmethod cljs.pprint/simple-dispatch
  my.ns.record
  [r] (print r))

I can't make any sense of the cljs.pprint documentation

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

Thu, 27 Apr 2023 19:12:03 +0000

This looks like a bug in ClojureScript 1.11.54 :

(conj {} [:a 1] '([:b 2] [:c 3]) '([:d 4]))

In Clojure on the JVM this is an error:

cljs.user> (conj {} [:a 1] '([:b 2] [:c 3]) '([:d 4]))
{:a 1, :b 2, :c 3, :d 4}
cljs.user> :cljs/quit
nil
user> (conj {} [:a 1] '([:b 2] [:c 3]) '([:d 4]))
Execution error (ClassCastException) at user/eval17754 (REPL:25).
class clojure.lang.PersistentVector cannot be cast to class java.util.Map$Entry (clojure.lang.PersistentVector is in unnamed module of loader 'app'; java.util.Map$Entry is in module java.base of loader 'bootstrap')

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

Mon, 24 Apr 2023 01:11:19 +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!

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

Mon, 17 Apr 2023 21:03:37 +0000

Wondering about these two loops in cljs.core/prefers*. Am I misreading it, or do they always return nil? Seems like the result of the inner when, which makes the recursive call to prefers*, is always dropped.
Also, if the intent of these two loops is a polymorphic lookup against the prefers table, should the calls to parents also be against the same hierarchy as with the isa? in cljs.core/dominates? Currently they are made against the global hierarchy.
Also, if there is no prefers table, or it is empty, you can probably skip the loops.

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

Thu, 30 Mar 2023 14:16:58 +0000

Hi everyone,
I have a Firefox addon written cljs with advanced optimization, after submit to addons, the reviews tell me that the zip file I submit is different from what they built from source.

I use diff-so-fancy to compare the generated js file, and I found the main difference are variable names.

So is there any way to ensure generated js are reproducible?

PS: My project source code is here:
https://github.com/jiacai2050/gooreplacer/blob/firefox/cljs-src/project.clj#L76

Feature request: async/await support in CLJS

Mon, 27 Mar 2023 23:57:27 +0000

There is a lot of discussion around the web related to adding ES2018 async/await to ClojureScript, be it feature requests[1][2], proposals[3], or experimentation[4][5].

I am posting this question so there is a central place where people can upvote and bring attention to the Clojure core team, and possibly help prioritize consideration of this feature.

I am aware it is not as easy as adding keywords to emitted JS code. I am aware of workarounds like using macros from promesa, core.async, or kitchen-async. I am also aware that there must be a strong use case for consideration on adding this feature. Everything I've mentioned, and more, has been discussed at one point in the links below.

[1] https://groups.google.com/g/clojurescript/c/scUMhU-ctEM
[2] https://www.reddit.com/r/Clojure/comments/f4nlau/clojurescript_and_asyncawait/
[3] https://observablehq.com/@shaunlebron/proposal-generators-and-async-functions-in-clojurescript#blockers
[4] https://twitter.com/roman01la/status/1155602189311717377
[5] https://twitter.com/borkdude/status/1639579880336621570

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

Tue, 14 Mar 2023 13:11:08 +0000

Currently, the docstring of with-redefs in CLJS reads:

cljs.core/with-redefs
([bindings & body])
Macro
  binding => var-symbol temp-value-expr

  Temporarily redefines vars while executing the body.  The
  temp-value-exprs will be evaluated and each resulting value will
  replace in parallel the root value of its var.  After the body is
  executed, the root values of all the vars will be set back to their
  old values. Useful for mocking out functions during testing.

It makes it seem as if it's perfectly fine to use it in a similar way you'd use the same macro in CLJ.
However, this comment by David Nolen says otherwise:

If you want something to be redefinable with with-redefs in production you need to mark those vars ^:dynamic.

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

Sun, 05 Feb 2023 00:11:40 +0000

I'm dealing with JSON data that always uses snake case. While it is possible to achieve what I want with clojure.walk, I think it would be convenient to add an option to js->clj to not only keywordize keys, but also demunge them, so that "some_key" becomes :some-key.

cljs.js/eval: def not working when using :simple optimization (works with :none/:whitespace)

Wed, 28 Dec 2022 15:51:59 +0000

as the title suggests, def appears to pass through without doing anything.

i.e. "(def x)" succeeds
but "(def x 10)" fails because
"Cannot read properties of undefined (reading 'x')"

article here: https://clojurescript.org/guides/self-hosting

suggests :simple optimization should work

to reproduce: https://github.com/sstraust/ClojureDefRepro (see comments for instructions)

Issue with ClojureScript macroexpansion equivalence

Tue, 15 Nov 2022 13:14:49 +0000

In ClojureScript forms can't always be replaced by they macroexpanded forms. This is the case for defrecord and defn on its multi arity version.

 clj -Sdeps '{:deps {org.clojure/clojurescript {:mvn/version "1.11.60"}}}' -M -m cljs.main                                                                          
ClojureScript 1.11.60
                                                                                                                                                   
cljs.user=> (defrecord ARecord [a])                                                                                                                                     
cljs.user/ARecord                                                                                                                                                  

cljs.user=> (macroexpand '(defrecord ARecord [a]))
(let* [] (do (defrecord* ...)))

cljs.user=> (let* [] (do (defrecord* ...)))
WARNING: Wrong number of args (4) passed to ARecord at line 1 <cljs repl>
WARNING: Wrong number of args (4) passed to ARecord at line 1 <cljs repl>
WARNING: Wrong number of args (4) passed to ARecord at line 1 <cljs repl>
WARNING: Wrong number of args (4) passed to ARecord at line 1 <cljs repl>
WARNING: Wrong number of args (4) passed to ARecord at line 1 <cljs repl>
WARNING: Wrong number of args (4) passed to cljs.user/ARecord at line 1 <cljs repl>
WARNING: Wrong number of args (4) passed to cljs.user/ARecord at line 1 <cljs repl>

Same thing happens trying to evaluate the forms resulting from this macroexpansion:

(macroexpand '(defn foo ([a] (foo a 5)) ([a b] (+ a b))))

Map destructuring works on singleton lists

Thu, 10 Nov 2022 08:15:43 +0000

(let [{x :x} '({:x "foo"})] x)
;; => "foo"

clojurescript cljs.main -t node compilation in recent releases does not create an `out` dir

Thu, 27 Oct 2022 18:07:40 +0000

Hi,

it appears as if there is a regression since cljs 1.10.748+ that when a node compilation is requested without explicitly specifying the outdir, a .cljs_node_repl directory is created as the output dir instead of out.

The default out compilation directory is not mentioned in cljs.main -h help, but it appears to be out by default, and this is backed by statement at the end of https://clojurescript.org/reference/repl-and-main :

Compiling Source

To compile ClojureScript source code, pass the main namespace to
cljs.main via the -c option:

java -cp src:cljs.jar cljs.main -c my-namespace.core

The output will be written to the directory specified via the -d
option (or out if unspecified), or to the file specified via the -o
option.

To reproduce
1. download both clojurescript 1.10.742 and clojuresript 1.10.748 jars, https://github.com/clojure/clojurescript/releases
2. create the getting started hello world program from https://clojurescript.org/guides/quick-start
3. execute java -cp "src;cljs-1.10.748.jar" cljs.main -t node -c hello-world.core, observe that a .cljs_node_repl directory has been created instead of the excpected out dir.

If one runs the same with and earlier version, e.g. java -cp "src;cljs-1.10.742.jar" cljs.main -t node -c hello-world.core they can observe that an out dir is created as expected.

This looks like a regression to me.

Workaround is to explicitly specify the directory, .e.g. java -cp "src;cljs-1.11.60.jar" cljs.main -t node -d out -c hello-world.core

Thanks