Clojure Q&A - Recent activity in Syntax and reader

Answer selected: Additional handling for `&` symbol in map destructuring for :keys/:syms/:strs could be a breaking change.

Thu, 09 Jul 2026 16:08:08 +0000

Yes, the intent here is to carve this out of being allowed so it is available for syntax purposes in destructuring. We did a fair amount of searching and do not see this being used anywhere.

We've updated the reference page at https://clojure.org/reference/reader#_symbols to explicitly note this.

Edited: Syntax-quoted lists can return nil, differs from ClojureScript

Sun, 28 Jun 2026 21:35:41 +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.

Closed: Implement reader literal and print support for PersistentQueue data structure

Tue, 09 Jun 2026 22:58:49 +0000

Clojure's PersistentQueue structure has been in the language for quite some time now and has found its way into a fair share of codebases. However, the creation of queues is a two step operation often of the form:

`
(conj clojure.lang.PersistentQueue/EMPTY :a :b :c)

;=> #
`

A better experience might be the following:

queue [:a :b :c]

;=> #queue [:a :b :c]

(pop #queue [:a :b :c])

;=> #queue [:b :c]
`

This syntax is proposed and discussed in the Clojure-dev group at https://groups.google.com/forum/?fromgroups#!topic/clojure-dev/GQqus5Wycno

Open question: Should the queue literal's arguments eval? The implications of this are illustrated below:

`
;; non-eval case

queue [1 2 (+ 1 2)]

;=> #queue [1 2 (+ 1 2)]

;; eval case

queue [1 2 (+ 1 2)]

;=> #queue [1 2 3]
`

The answer to this open question will determine the implementation.

Commented: `eval` using functions with metadata

Thu, 04 Jun 2026 02:35:24 +0000

#= is undocumented because it is not intended to be used outside the compiler.

Answer selected: Literals for Unicode code points (and perhaps also sequences thereof)

Tue, 10 Feb 2026 02:29:51 +0000

Created feature request jira https://clojure.atlassian.net/browse/CLJ-2935

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"

Commented: [clojure.edn] Leading zeros in numbers

Tue, 16 Dec 2025 09:03:08 +0000

I was referring to this part of edn specification when I say "even for floats":

    floating-point-number
      int M
      ,,,
    digit
      0-9
    int
      digit
      1-9 digits
      + digit
      + 1-9 digits
      - digit
      - 1-9 digits

Based on this 042M is invalid number according to edn spec but clojure reads it as BigDecimal 42.

Commented: Aliased namespace in tagged literal

Thu, 11 Dec 2025 20:39:51 +0000

I didn't edit it here, just on the jira.

Answer selected: clojure.edn and clojure allows keywords with empty ("") namespaces

Wed, 10 Dec 2025 06:05:09 +0000

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

Other old and related JIRAs for relevance: CLJ-1286 CLJ-1252

Commented: Support characters beyond basic multilingual plane

Tue, 02 Dec 2025 20:38:46 +0000

All that is just the nature of the complicated situation of "char"s and Unicode and how they are exposed by the JVM / JDK.

Commented: Double colon ("::") in the middle or at the end of identifier.

Tue, 02 Dec 2025 17:11:31 +0000

Is there a possibility to consider relaxing this rule? That would mean one constraint less in compare with pure edn specification.

Commented: clojure.edn/read invoke user-supplied reader functions when tagged literal is to be discarded by discard macro

Tue, 25 Nov 2025 21:27:41 +0000

I cleaned up the ticket and added a patch.

Answer selected: Inconsistent errors in ratio parsing with either `clojure.edn/read` or `clojure.core/read`

Tue, 25 Nov 2025 20:24:15 +0000

Ratios in Clojure are rational ratios with integer numerator and denominator. Ratio syntax is not a composite of integer or other numeric syntaxes, it is its own definition where the numerator and denominator are strings of digits of arbitrary length (treated as long or biginteger as necessary based on scale).

The syntax is semantically defined as:
sign? digit+ '/' digit+

The regex pattern is currently:
"([-+]?[0-9]+)/([0-9]+)"

This pattern incorrectly allows leading 0 and should be narrowed.

Filed jira at https://clojure.atlassian.net/browse/CLJ-2925

The other errors are expected and these syntaxes are not supported.

Closed: Suggestion: allow docstrings in defonce like in def

Sat, 01 Nov 2025 18:42:12 +0000

When defining vars, we can provide docstrings in between the symbol and the binding. e.g.

(def some-var 
  "this var serves as an example" 
  42)

However, we cannot currently do so with defonce. We must resort to providing metadata manually as follows.

(defonce 
  ^{:doc "this var serves as another example"}
  other-example nil)

It would be nice to be able to use docstrings like we can in def, defn, etc. in a future release of Clojure.

Commented: Do you use arity 3 or higher comparisons such as = < <= > >= == in performance sensitive code?

Tue, 12 Aug 2025 21:55:08 +0000

Ah, thanks for that insight. I thought about the arity 3 as an obvious optimization and taking the list processing hit later, in fewer cases.

Answer selected: .pow bigdec vs bigint

Tue, 29 Jul 2025 12:56:56 +0000

Per the reference, the Clojure bigint type is clojure.lang.BigInt, which is like java.math.BigInteger but optimized for ops in the long range. Because there are lots of ways you can end up with java.lang.BigInt, both are supported in lots of places. If you're going after specific interop on the type, you'll need to confine yourself to clojure BigInt or else use biginteger to get to java BigInteger.

Commented: Associative destructuring with if-let

Sat, 07 Jun 2025 18:43:26 +0000

Thank you for the comment. I guess what confused me in the first place is that I got the steps in the wrong order : I thought it was compute/destructure/evaluate truthiness, whereas as you said it's compute/evaluate truthiness/destructure.

Commented: clojure.edn parser will not parse complete file in some cases

Wed, 07 May 2025 14:42:23 +0000

Yeah, I've overlooked that part in docstring :D Thanks!

Answered: Symbols with leading slashes

Thu, 17 Apr 2025 14:39:40 +0000

There are no plans to widen what is allowed in symbols.

The symbol function supports things wider than the spec for the same reasons keyword does which are outlined at https://clojure.org/guides/faq#unreadable_keywords - in short, programatic use and performance.

Answered: Consider postponing setting the default values of destructured map keys that might rely on other keys

Fri, 28 Mar 2025 15:29:28 +0000

The intent of :or is to provide a default value for missing values, not to provide an arbitrary expression over things that are in the process of being bound by the destructuring itself. This is not a feature we want to support.

Answered: Add digit separators support to number literals.

Fri, 01 Nov 2024 19:09:36 +0000

Not sure it's a good idea, but here's a macro that you can try without having to change the language. You would have to wrap the underbar literals in an (und ...) macro call. Also, note that the most convenient style requires a leading _ on the (fake) symbol notation. Or you can use a (questionable) keyword or a string. A legal number should also work just for completeness.

(defmacro und [lit]
  (if-let [s# (if (string? lit) lit (when (instance? clojure.lang.Named lit) (name lit)))]
    `~(clojure.edn/read-string (clojure.string/replace s# "_" ""))
    lit))

;;; valid uses returning 123456
;;; note: bare symbol style must start with _
(und 123456)
(und _123_456)
(und :123_456)
(und "123_456")

Closed: locals closed over by a ^:once fn aren't cleared if the fn is in a branch

Sat, 03 Aug 2024 18:39:59 +0000

Minimal case:

`
(fn foo [x]
(if true

(^:once fn* []
 ;; x is not cleared here
 x)))

This is a severe bug as it means that every local used inside a loop or try/catch expression that the clojure compiler internally hoists in a FNONCE, in a conditional branch, cannot be cleared at the moment.

As a concrete example reported in slack,

`
;; THIS OOMs
(defn test1 [x]
(if true

(do
  (try (doseq [_ x] _))
  1)
0))

(test1 (take 1000000 (range)))

;; THIS DOESN'T OOM
(defn test2 [x]
(do

(try (doseq [_ x] _))
1))

(test2 (take 1000000 (range)))

Approach: don't set a new clearing frame if the fn is ^:once and there's an existing clearing frame
Patch: 0001-CLJ-2145-fix-clearing-of-locals-closed-over-by-a-FNO.patch

Closed: Specifically allow '.' inside keywords

Wed, 29 May 2024 14:20:02 +0000

The documentation for keywords (on page http://clojure.org/reader) specifically states that '.' is not allowed as part of a keyword name; however '.' is specifically useful. For example, several web frameworks for Clojure use keywords to represent HTML elements, using CSS selector syntax (i.e., :div.important is equivalent to

In any case, the use of '.' is not checked by the reader and it is generally useful.

I would like to see '.' officially allowed (in the documentation). Further, I'd like to see additional details about which punctuation characters are allowed (my own web framework uses '&', '?' and '>' inside keywords for various purposes ... again, current reader implementation does not forbid this, but if a future reader will reject it, I'd like to know now).

Commented: Clarify and align valid symbol and keyword rules for Clojure (and edn)

Thu, 16 May 2024 15:51:17 +0000

With a cursory look at the current pages (the guide: https://clojure.org/guides/weird_characters and the reference: https://clojure.org/reference/reader), seems like some of this has been addressed but not all.

I wonder how out of date this Ask and the associated Jira ticket are, if they should be updated/closed.

Closed: Can Clojure support a byte-array literal?

Sun, 10 Dec 2023 16:46:08 +0000

Byte arrays are fundamental to many domains: cryptography, audio and video processing, file handling, socket ops, etc. Clojure's host platforms support byte arrays and Clojure itself even offers an immutable byte array (clojure.core.Vec).

Unfortunately, there is no support for a byte array literal and various attempts to add support have not been successful for surprising reasons.

Am I missing something, or is this simply not possible? And if it's not possible, could such support be added?

Commented: Clojure reader fails to suppress cljs namespaced keywords

Tue, 07 Nov 2023 20:50:04 +0000

No, I don't think there is any workaround, unless maybe you created the namespace yourself first and created the alias to a different (existing) namespace before loading.

Commented: Location data on all IObj

Thu, 19 Oct 2023 20:33:40 +0000

I am also very interested in this feature. I would like to use it in conjunction with `clojure.lang.Compiler/analyze` to find all usages of a local binding in a given Clojure form to, in a Clojure editor, highlight all such usages and give the user the possibility to rename the binding and all its usages.

As it is, I have to rely on clojure.tools.reader to assign line and column numbers to each read form.

Besides that, I think this feature would enable other useful static analysis and error reporting features.

As far as my use case is concerned, at least, it would be enough if this were an optional feature of `read` that'd be off by default.

Comment edited: should `clojure.core/=` have a zero arity?

Sat, 16 Sep 2023 12:38:50 +0000

Reminds me of an old Swedish joke. Roughly translates to:

- What's the difference between a fish?
- It can neither ride a bicycle!

Answer selected: Why can't unknown tagged literals be embedded in expressions when `default-data-reader-fn` is set to `tagged-literal`?

Thu, 14 Sep 2023 15:09:11 +0000

Yes, it should, logged as https://clojure.atlassian.net/browse/CLJ-2801

Closed: improve syntax errors on tagged-literals

Wed, 08 Mar 2023 16:00:51 +0000

When we write a symbol in the UUID literal, the reported error message is wrong

(as of 1.11.1)

clojure -M -e '#uuid id'
Execution error (AssertionError) at clojure.main/main (main.java:40).
Assert failed: (string? form)

It is wrong because

It is not an execution error. Should be read or syntax error.
It does not include any ex-data: https://clojure.org/reference/repl_and_main#_error_printing

It should be something like this

Reader error (AssertionError) at clojure.uuid/default-uuid-reader (uuid.clj:12).
Assert failed: (string? form)

A second step improvement could be add spec support to data-literals, as macros do.

Syntax error reading #uuid id at (REPL:1)
id - failed: string? at: [:form]

From #clojure-dev slack channel

Alex: You don’t need anything special there - just an instrumented spec on the data reader fn

After run

(s/fdef clojure.uuid/default-uuid-reader :args (s/cat :form string?))
(clojure.spec.test.alpha/instrument `clojure.uuid/default-uuid-reader)

The message turns into

Syntax error reading source at (REPL:2:1).
Call to #'clojure.uuid/default-uuid-reader did not conform to spec.

This is a way better message.

Also, it includes a #:clojure.error{:phase :read-source} in ex-data.
So the fix could be just add a spec to clojure.uuid/default-uuid-reader

Answered: Numeric keywords work but not numeric names in qualified keywords?

Mon, 30 Jan 2023 19:46:34 +0000

See https://clojure.org/guides/faq#keyword_number for more info

Answer selected: How to put the records of my file into a defined list and use it after in my code?

Thu, 08 Dec 2022 23:59:27 +0000

So, I think the main thing here is that doseq returns nil, not a list.

Perhaps something like this will get you started...

file.txt:

1|Xxx|info1|222-2222
2|Yyy|info2|333-3333
3|Zzz|info3|444-4444

Then, in the REPL:

user> (defn load-data
        [filename]
        (with-open [r (clojure.java.io/reader filename)]
          (-> (for [line (line-seq r)]
                (let [[id name info phone] (clojure.string/split line #"\|")]
                  [(Integer/parseInt id) name info phone]))
              (doall))))
#'user/load-data
user> (load-data "file.txt")
([1 "Xxx" "info1" "222-2222"]
 [2 "Yyy" "info2" "333-3333"]
 [3 "Zzz" "info3" "444-4444"])

Notably, the doall is necessary here, since for returns a lazy sequence; without the doall, with-open will close the reader before anything is read.

Answered: Complete beginner - questions about formatting, structure etc...

Thu, 08 Dec 2022 18:30:10 +0000

On the subject of formatting and idioms, you may find the unofficial community https://guide.clojure.style/ helpful.

Answer selected: Read-time evaluation of macros causes errors

Tue, 11 Oct 2022 21:35:50 +0000

Read-eval is not a public feature and generally you should not use it. This is a big (and intentional) difference from Common Lisp. It is primarily used internally in some corner cases to read forms that reconstruct Java objects that lack print forms.

Answered: Why i get the "Could not locate hugsql/core__init.class, hugsql/core.clj or hugsql/core.cljc on classpath." ?

Mon, 26 Sep 2022 17:54:47 +0000

Oh i'm sorry i think i've already get the solution. After i restart the nREPL, eveything is running normaly.
But need to change some of the code.

From

(hugsql/def-db-fns "resources/users.sql")

(hugsql/def-db-fns "users.sql")

Answer selected: Behaviour of for is different when loading a file versus typing in the REPL

Wed, 29 Jun 2022 12:29:02 +0000

According to the docs (https://clojure.github.io/clojure/clojure.core-api.html#clojure.core/map), map returns a lazy sequence, which means the work is not done (in particular the prn's do not happen) until the sequence is consumed. As Eugene Pakhomov points out in another answer, the REPL consumes the sequence, but the forms in the file by themselves did not.

Because map returns a lazy sequence, one does not usually rely on map for side effects like printing. doseq is good for executing side effects. Besides the question of timing, you usually need either the data (sequence) or the side effects, so it is convenient that doseq does not amass a sequence.

Answer selected: Has middle of sequence &rest destructuring been considered?

Wed, 22 Jun 2022 15:58:22 +0000

In what scenario would this be useful?

Answer selected: Why i get different result on the same sequence?

Tue, 14 Jun 2022 12:09:06 +0000

Let's take a look at what clojure.string/includes? says it does and how it is implemented:

user=> (doc clojure.string/includes?)
-------------------------
clojure.string/includes?
([s substr])
  True if s includes substr.
nil
user=> (source clojure.string/includes?)
(defn includes?
  "True if s includes substr."
  {:added "1.8"}
  [^CharSequence s ^CharSequence substr]
  (.contains (.toString s) substr))
nil
user=> (.toString (map :name [{:name "One"} {:name "Two"}]))
"clojure.lang.LazySeq@26e067"
user=> (.toString ["One" "Two"])
"[\"One\" \"Two\"]"
user=>

We see that it assumes its first argument is a string -- or more specifically a CharSequence -- and it starts out by calling .toString on that argument.

We see that (.toString (map .. ..)) produces a cryptic-looking string but this is because map produces a lazy sequence and the default string representation of a lazy sequence is its type and a hex value, like any Java object that doesn't have a specific string representation.

However, calling .toString on a quoted list or a vector produces a string representation of the elements of the list or vector.

Consequently, clojure.string/includes? "works" in the latter case because even though you are not passing it a CharSequence, when it converts the data structure to a string, it includes the name you are looking for.

Since you want to check if any element of the sequence contains the string, what you probably want here is:

(some #(clojure.string/includes? % "Joni") (map :name (mapify ..)))

Answered: atom value different results

Fri, 03 Jun 2022 21:09:12 +0000

My first guess would be for's laziness. Try (def cnt' (vec (for[i (range 5)] (shift-by i)))) and see if that changes things.

Answered: What is the difference between "keyword" and "atom"?

Sat, 23 Apr 2022 23:50:34 +0000

Ignoring atoms completely, here's an informal perspective on keywords:

I like to think of keywords conceptually like a string/symbol hybrid with special superpowers. Like symbols, they're restricted to certain characters (notably, no spaces allowed) and can be namespaced: :myproject.api/foo. Like strings, they're really just a data primitive.

The main keyword superpower is that they can be called as functions to get values out of associative data structures like hash-maps: (:foo {:foo 42 "bar" 36}) => 42 and sets: (:foo #{:foo :bar}) => :foo. You can't use strings or numbers as functions.

Here's a helpful StackOverflow answer about why keywords exist in Clojure: https://stackoverflow.com/a/11655615

Answered: java interop, property same name as object

Tue, 15 Mar 2022 23:43:04 +0000

I attempted to reproduce based on the code above and it failed to reproduce

% cat A.java
public class A {

public int af() { return 2; }
public int af1(int x) { return x+2; }
public int a = 1;
static public int as;
static public int afs() { return 20; }
static public int afs1(int x) { return x+20; }

}
% javac A.java
% clojure -Scp "."
Error: Could not find or load main class clojure.main
Caused by: java.lang.ClassNotFoundException: clojure.main
zsh: exit 1     clojure -Scp "."
% clojure -Sdeps '{:paths ["."]}'
Clojure 1.10.2
user=> (import A)
A
user=>  (def a (A.))
#'user/a
user=> (def x (A.))
#'user/x
user=> (def a1 (A.))
#'user/a1
user=>  (.a a1)
1
user=> (.a x)
1
user=>  (.a a)
1
user=>

It looks like your clojure script is not the tools.deps clojure script, since that has no -cp option, what script is it and what else is it doing besides launching clojure? Your repl also doesn't print the version of clojure when you start it, what repl are you using, what version of clojure?

Answered: Why does if-not call not instead of reversing the forms with if?

Tue, 25 Jan 2022 00:08:29 +0000

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

This has definitely come up on Slack before, don't know of a jira/ask for it.

I don't think it's a huge deal, could see it mostly coming up if it blows the inline code size boundary or something like that. Difficult to come up with that case, but maybe it would be amenable to a microbenchmark. If anyone does test it, it's important to check Java 8, 11, 17 - this is exactly the kind of thing the jvm gets better at over time and it could easily be less important on newer jvm.

Answered: Should Clojure automatically load namespaces of vars defined in data_readers.clj?

Tue, 23 Nov 2021 10:50:21 +0000

It would be great if this behaviour changed or could be configured.

Currently it's pretty hard to use dev time tools like hasp or debux, since you have to either require them everywhere or use workarounds like user.clj inject to get the require.

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

Tue, 09 Nov 2021 22:39:21 +0000

any? is a predicate that is intended to always return true, so yes it is the correct behavior. any? was added as a predicate to use with spec in the case where any value is valid. It is not a complement to not-any?, despite that obvious assumption. There are, in the end, only so many words and despite a lot of care in this regard, there are times when these confusions exist.

Re "I believe any? should take two arguments and return true if any predicate is true.", this is similar to and (for N args) but that does have limits as a macro, or every? (for a coll), or the higher-order function every-pred for creating a composite pred. Depending on your case, one of those probably makes sense.

Are there design considerations behind allowing keywords to be functions, but not strings or numbers?

Wed, 08 Sep 2021 20:24:28 +0000

related to a thread on clojureverse: https://clojureverse.org/t/x-x-auto-transducifying-thread-macros/8122/26

,where the author's library provides a transducerized variant of ->> called x>> that recog,nizes transducers and tries to turn the threading expression into an efficient transducer form.

The author then decided to fold in keyword-access semantics for strings and numbers, to enable threaded expressions that equate to get or get-in with less verbosity. Something like

(let [m {1 {"b" [0 1 {:c :res}]}}]
     (x> m 1 "b" 2 :c name)) ;=> "res"

which is akin to the keyword idiom of

(-> m :a :b :c) ;;some-nested-value

Is there any reason why in the general case, eval should not support keyword access semantics for other simple types like numbers and strings (maybe booleans, whatever)?
Aside from being unable to extend IFn to strings and numbers (this would have to be handled with additional type checks dispatching on the first arg instead of focusing on IFn), are there language design arguments against this? I am unable to derive any off the top of my head.

Why do some reader tags throw when evaluated on their own?

Tue, 17 Aug 2021 17:52:04 +0000

For example, take the #ordered/map tag (reader kv defined here, data reader fn). If I eval the following code, I get an exception thrown.

(do #ordered/map ([:b 2] [:a 1] [:d 4]))
Syntax error compiling fn* at (/src/example.clj:6:3).
	at clojure.lang.Compiler.analyzeSeq(Compiler.java:7119)
java.lang.IllegalArgumentException: Unable to resolve classname: IPersistentMap
	at clojure.lang.Compiler$HostExpr.tagToClass(Compiler.java:1129)
	at clojure.lang.Compiler.tagClass(Compiler.java:8693)
	at clojure.lang.Compiler$ObjExpr.emitValue(Compiler.java:4810)
	at clojure.lang.Compiler$ObjExpr.emitConstants(Compiler.java:4938)
	at clojure.lang.Compiler$ObjExpr.compile(Compiler.java:4616)
	at clojure.lang.Compiler$FnExpr.parse(Compiler.java:4110)
	at clojure.lang.Compiler.analyzeSeq(Compiler.java:7109)
	at clojure.lang.Compiler.analyze(Compiler.java:6793)
	at clojure.lang.Compiler.eval(Compiler.java:7178)
	at clojure.lang.Compiler.eval(Compiler.java:7171)
	at clojure.lang.Compiler.eval(Compiler.java:7136)
	at clojure.core$eval.invokeStatic(core.clj:3202)
	at clojure.core$eval.invoke(core.clj:3198)
	at nrepl.middleware.interruptible_eval$evaluate$fn__939.invoke(interruptible_eval.clj:91)
	at clojure.main$repl$read_eval_print__9110$fn__9113.invoke(main.clj:437)
	at clojure.main$repl$read_eval_print__9110.invoke(main.clj:437)
	at clojure.main$repl$fn__9119.invoke(main.clj:458)
	at clojure.main$repl.invokeStatic(main.clj:458)
	at clojure.main$repl.doInvoke(main.clj:368)
	at clojure.lang.RestFn.invoke(RestFn.java:1523)
	at nrepl.middleware.interruptible_eval$evaluate.invokeStatic(interruptible_eval.clj:84)
	at nrepl.middleware.interruptible_eval$evaluate.invoke(interruptible_eval.clj:56)
	at nrepl.middleware.interruptible_eval$interruptible_eval$fn__965$fn__969.invoke(interruptible_eval.clj:155)
	at clojure.lang.AFn.run(AFn.java:22)
	at nrepl.middleware.session$session_exec$main_loop__1067$fn__1071.invoke(session.clj:190)
	at nrepl.middleware.session$session_exec$main_loop__1067.invoke(session.clj:189)
	at clojure.lang.AFn.run(AFn.java:22)
	at java.base/java.lang.Thread.run(Thread.java:829)

The map is read and the data reader fn is called as expected.

(def omap #ordered/map ([:b 2] [:a 1] [:d 4]))
=> #'example/omap
(type omap)
=> flatland.ordered.map.OrderedMap

It's only when eval'ing just the tagged literal that the ex is thrown. Any idea why this is happening?

Why does data-readers require Vars?

Tue, 10 Aug 2021 19:04:31 +0000

edn/read's :readers arg accepts a map of tag symbols to data-reader functions, but *data-readers* requires a map of tag symbols to data-reader Vars (global bindings). I'm just wondering if there is any reason for the discrepancy, because it is a bummer not to be able to use anonymous functions in *data-readers*.

The context is I've made a handful of related reader tags (for tagged literals) that all work similarly, so rather than create 5 near identical reader functions I made 1, with two arity (tag, value), then I made a reader-for function that returns a one-arity function as needed (using partial and the two-arity function). This works just fine for edn/read but when I went to use it in *data-readers* it's a no-go because there is no Var for what comes out of reader-for.

There are several workarounds. For example bind *default-data-reader-fn*and make a function to dispatch to all my readers. Which is not particularly difficult but now I'm left with two artifacts instead of one - the map of readers for edn/read and the function for *default-data-reader-fn*. The map can be leveraged in the function of course. Or as an alternative I can just write the five functions -- or "write" them in a doseq. But the little inconsistencies across how these tags are done is a little baffling. (For example, in addition to the {tag-sym fn} map of :reader and the {tag-sym Var} map of *data-readers*, there is also the {unquoted-tag-sym-in-a-map-literal fn-sym} syntax of data_readers.clj, which despite being a clj file does not seem to afford me the opportunity to do anything dynamic to define readers, just the literal map).

I probably just don't grasp the practicalities/history/logic behind all this, if anyone can shed some light thanks in advance, if not that's fine too.

Clojure's handling of non-arabic numeral digits is surprising

Mon, 12 Jul 2021 18:52:13 +0000

A friend of mine is writing a DSL and wants to use the character ૪ as part of his notation. If you try to use this character as part of a symbol in clojure you get an error like the following:

user=> (read-string "૪")
Execution error (NumberFormatException) at user/eval5 (REPL:1).
Invalid number: ૪
user=>

The cause of this appears to be:

user=> (Character/isDigit \૪)
true
user=>

The character is a digit in Gujarati script so java's Character/isDigit returns true, so the clojure reader tries to parse it as a number, but it can only handle arabic numerals (and maybe hex).

It seems like if the reader is going to rely on Character/isDigit, it should be able to turn any of those characters into a number or the reader should allow "digits" it doesn't know how to handle to be symbols.

How to define constantly using #()?

Sun, 18 Apr 2021 07:18:37 +0000

I started learning Clojure. The tutorial asks to define constantly. I managed it using fn. How to do it using #()?

Are reader tags supposed to support non-ASCII characters?

Thu, 15 Apr 2021 05:48:03 +0000

I tried defining a Unicode data-literal tag, and was surprised to find that it throws an error:

(defn wrap-λ [expr]
  `(fn [~'%] ~expr))
    
(set! *data-readers*
  (assoc *data-readers*
    'λ #'wrap-λ))

(read-string "#λ(inc %)")
;; => Execution error (ArrayIndexOutOfBoundsException) at lib/eval74486 (REPL:15).
;;    Index 955 out of bounds for length 256

955 is the Unicode codepoint for \λ, and the error suggests it only supports the ASCII range.
The first few lines of the stacktrace:

       LispReader.java:  840  clojure.lang.LispReader$DispatchReader/invoke
       LispReader.java:  285  clojure.lang.LispReader/read
       LispReader.java:  216  clojure.lang.LispReader/read
       LispReader.java:  205  clojure.lang.LispReader/read

Is this expected behavior? Clojurescript does not have the same issue:

(cljs.reader/register-tag-parser! 'λ wrap-λ)
(cljs.reader/read-string "#λ(inc %)")
;; => (cljs.core/fn [% & args] (inc %))

Clojure Q&A - Recent activity in Syntax and reader

Answer selected: Additional handling for `&` symbol in map destructuring for :keys/:syms/:strs could be a breaking change.

Edited: Syntax-quoted lists can return nil, differs from ClojureScript

Closed: Implement reader literal and print support for PersistentQueue data structure

queue [:a :b :c]

queue [1 2 (+ 1 2)]

queue [1 2 (+ 1 2)]

Commented: `eval` using functions with metadata

Answer selected: Literals for Unicode code points (and perhaps also sequences thereof)

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

Commented: [clojure.edn] Leading zeros in numbers

Commented: Aliased namespace in tagged literal

Answer selected: clojure.edn and clojure allows keywords with empty ("") namespaces

Commented: Support characters beyond basic multilingual plane

Commented: Double colon ("::") in the middle or at the end of identifier.

Commented: clojure.edn/read invoke user-supplied reader functions when tagged literal is to be discarded by discard macro

Answer selected: Inconsistent errors in ratio parsing with either `clojure.edn/read` or `clojure.core/read`

Closed: Suggestion: allow docstrings in defonce like in def

Commented: Do you use arity 3 or higher comparisons such as = < <= > >= == in performance sensitive code?

Answer selected: .pow bigdec vs bigint

Commented: Associative destructuring with if-let

Commented: clojure.edn parser will not parse complete file in some cases

Answered: Symbols with leading slashes

Answered: Consider postponing setting the default values of destructured map keys that might rely on other keys

Answered: Add digit separators support to number literals.

Closed: locals closed over by a ^:once fn aren't cleared if the fn is in a branch

Closed: Specifically allow '.' inside keywords

Commented: Clarify and align valid symbol and keyword rules for Clojure (and edn)

Closed: Can Clojure support a byte-array literal?

Commented: Clojure reader fails to suppress cljs namespaced keywords

Commented: Location data on all IObj

Comment edited: should `clojure.core/=` have a zero arity?

Answer selected: Why can't unknown tagged literals be embedded in expressions when `*default-data-reader-fn*` is set to `tagged-literal`?

Closed: improve syntax errors on tagged-literals

Answered: Numeric keywords work but not numeric names in qualified keywords?

Answer selected: How to put the records of my file into a defined list and use it after in my code?

Answered: Complete beginner - questions about formatting, structure etc...

Answer selected: Read-time evaluation of macros causes errors

Answered: Why i get the "Could not locate hugsql/core__init.class, hugsql/core.clj or hugsql/core.cljc on classpath." ?

Answer selected: Behaviour of for is different when loading a file versus typing in the REPL

Answer selected: Has middle of sequence &rest destructuring been considered?

Answer selected: Why i get different result on the same sequence?

Answered: atom value different results

Answered: What is the difference between "keyword" and "atom"?

Answered: java interop, property same name as object

Answered: Why does if-not call not instead of reversing the forms with if?

Answered: Should Clojure automatically load namespaces of vars defined in data_readers.clj?

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

Are there design considerations behind allowing keywords to be functions, but not strings or numbers?

Why do some reader tags throw when evaluated on their own?

Why does *data-readers* require Vars?

Clojure's handling of non-arabic numeral digits is surprising

How to define constantly using #()?

Are reader tags supposed to support non-ASCII characters?

Answer selected: Why can't unknown tagged literals be embedded in expressions when `default-data-reader-fn` is set to `tagged-literal`?

Why does data-readers require Vars?