Clojure Q&A - Recent questions in Syntax and reader

destructuring with :keys! and :or

Tue, 14 Jul 2026 19:52:33 +0000

I'm trying Clojure 1.13.0-alpha4. I have a problem with :keys! and :or. The first example works as expected with the old :keys. The second example gives me a syntax error when I switch to the new :keys!. The third example works when I avoid the required key in the defaults.

 (let [{:keys [a] :or {:a 1}} {:a 2}] a)
 ;=> 2
    
(let [{:keys! [a] :or {:a 1}} {:a 2}] a)
Syntax error macroexpanding let at (REPL:1:1).
Can't supply default value for required key: :a

(let [{:keys! [a] :or {:b 1}} {:a 2}] a)
;=> 2

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

Thu, 09 Jul 2026 10:01:25 +0000

Before 1.13.0-alpha1:

(let [{:keys [&]} {:& 1}] &)
;; => 1

After:

(let [{:keys [&]} {:& 1}] &)
Syntax error compiling at (REPL:1:1).
Unable to resolve symbol: & in this context

Syntax-quoted lists can return nil, differs from ClojureScript

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

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

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

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

Clojure 1.12.5
user=> `()
()

ClojureScript returns an empty list in these cases:

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

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

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

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

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

`eval` using functions with metadata

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

TIL:

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

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

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

This was unintuitive to discover.

I solved it locally with a little helper:

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

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

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

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

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

So I suppose my questions are:

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

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

Mon, 12 Jan 2026 20:02:41 +0000

Context
For historical reasons the JVM type system's support for Unicode code points is poor, and while this is usually invisible to the developer it becomes a hassle when String literals containing non-Latin1 code points are used in code. It also becomes particularly problematic when cross-platform (cljc) code is attempting to do this, since other platforms may not share this historical oddity so solutions that "work" in ClojureJVM may break in other dialects.

For example, the transgender flag emoji (a single grapheme cluster that happens to be defined by 5 Unicode code points) cannot easily be constructed at the REPL or in a source file without detailed knowledge of the JVM's history (and associated knowledge of UTF-16, an increasingly obsolete character encoding).

Using the documented code points for this grapheme cluster with the JVM's Unicode escaping mechanism does not give the expected outcome:

The correct, but unintuitive solution is to remember that the JVM does not directly support Unicode code points in the supplemental planes, and then to translate the supplemental code point U+1F3F3 into its UTF-16 code unit / surrogate pair representation:

Note: I had to use screenshots for this, since ask.clojure doesn't appear to support Unicode supplemental code points properly either...

Question/request/proposal
Clojure can sidestep this issue in a purely accretive manner, providing better consistency across the JVM and other runtimes, by adding direct support for Unicode literals.

This would involve adding a new literal syntax that represents a single Unicode code point, and perhaps also a new literal syntax that represents a sequence of Unicode code points (perhaps supporting not only the novel Unicode code point literal, but also the existing Character and String literals). Both of these new literals would produce a standard JVM (or JavaScript, or ...) String object, in whatever native encoding those objects employ on their respective platforms - after such literals are read, it's all just the extant String data type - there is no runtime impact.

An example literal syntax

While I am not proposing a specific syntax for these new literals here (though such a task is a necessary step), for illustrative purposes here is an example of what these literals might approximately look like:

Single Unicode code point literals:

#U+0061: produces a String containing the Latin letter a: "a"
#U+1F921: produces a String containing the clown emoji (which ask.clojure cannot display)

Sequences of Unicode code point literals:

#U+[U+0061 U+0020 U+1F921]: produces the 3 grapheme cluster String: "a <clown emoji>"
#U+["a " U+1F921]: produces the same String, but demonstrates why it may be useful to support a mix of literals within the sequence (for readability)
#U+[\a \space U+1F921]: ditto
#U+[U+1F3F3 U+FE0F U+200D U+26A7 U+FE0F]: produces a String containing a single grapheme cluster (the transgender flag emoji)

This final example is an ideal test case, since the transgender flag emoji is a single Unicode grapheme cluster, defined by 5 Unicode code points, but on the JVM (for the historical reason listed originally) is made up of 6 Characters.

Note that the sequence literal may not be necessary, since str could be used with the single code point literal syntax; e.g. (str #U+1F3F3 #U+FE0F #U+200D #U+26A7 #U+FE0F). Whether shifting the cost of string concatenation from read-time to runtime matters or not is another topic worthy of deeper consideration.

Other notes
Orthogonal to this proposal (at least from a Clojure core perspective; from a user perspective they're closely related), it would also be useful if Clojure core (perhaps in the clojure.string namespace) had functions to turn Strings into sequences of code points (as integers) and vice versa. Both the JVM and JavaScript provide native APIs for doing this (and presumably other platforms do too), but providing these as standard functions in Clojure core (similar to what was done with parse-long, parse-double, and parse-boolean in Clojure v1.11) has value and is also purely accretive.

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"

Aliased namespace in tagged literal

Thu, 11 Dec 2025 20:01:16 +0000

Set up

Tagged literals are defined by setting a namespaced symbol in data_readers.clj (or data_readers.cljc). At load, Clojure merges all of the maps defined in data_readers.clj(c) files found on the classpath into a single map. At read time, the symbol following a # is checked in the merged data readers map, which determines which var to call with the contents of the following form.

For example, #foo/bar [1 2 3] leads to the reader calling the equivalent of (get *data-readers* 'foo/bar).

Problem statement

The tag of a tagged literal must be determined when it is created. The namespace of the chosen tag is set and cannot be changed by a user. Unlike a fully qualified symbol with an aliased namespace, a tagged literal must what was chosen by the author.

As an author of tagged literals, I want to write tags that will not clash with other tags by giving them complex/deep namespaces. For example, {noahtheduke.lazytest/expect noahtheduke.lazytest/expect}.

As a user of tagged literals, I want to alias the namespace of tags and use it in my code. For example:

;; in src/data_readers.clj
{noahtheduke.lazytest/expect noahtheduke.lazytest/expect}

;; in test/noahtheduke/example_project/main-test.clj
(ns noahtheduke.example-project.main-test
  (:require
   [noahtheduke.lazytest :as-alias lt]
   [noahtheduke.lazytest.core :refer [defdescribe it]]))

(defdescribe some-test
  (it "works"
    #lt/expect (= 1 2)))

EDN

This is not related to edn at all and any potential change will be to Clojure itself.

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

Fri, 05 Dec 2025 09:56:54 +0000

Following links and snippets are about clojure.edn but because this logic is the same in clojure it also affects clojure reader as well.

Here is how symbol pattern is defined:

[:]?([\D&&[^/]].*/)?(/|[\D&&[^/]][^/]*)

It is eagerly matching prefix until the last slash character, after that it matches symbol name.

Then there is a wrong analysis of matched groups happen: ns is incorrectly set to everything until the last slash with validation that it is not ends with :/

Then in Symbol.intern call there is an another lookup for the first slash to split symbol into namespace and name.

The result is that keywords like this: ":/-/-", end up with namespace set to empty string "".

Looks like the least intrusive way to fix it is to use the same logic to find namespace borders in both places:

during symbol reading, lookup the first / to set ns instead of using the first matching group
in symbol interning the logic is correct

Another option is to use different regular expression:

[:]?([\D&&[^/]][^/]*/)?(/|[\D&&[^/]].*[^/])

This matches symbol prefix til the first slash keeping restriction "name can't end with slash".

[clojure.edn] Leading zeros in numbers

Thu, 04 Dec 2025 13:31:23 +0000

clojure.edn allow leading zeros ending up reading such number as octal representation. The problem is that it is also allowed to have indefinite amount of leading zeros for octals:

000000000000042  ;; => 34

and when there is a suffix "M" that forces floating point representation the same string become float 42 stripping all leading zeros.

000000000000042M ;; => 42M

At the same time EDN specification forbids integers with leading zeros at all even for floats.
I found a ticket about leading zeros in data.json but I think it should be expanded to cover clojure as well.

In the same scope but origin is in the EDN spec:
float specification allows leading zeroes in exponent and only zeros in fractional parts:

0.00000000...00
0.0e0001

probably because of that clojure.edn read such numbers without error too.

Support characters beyond basic multilingual plane

Tue, 02 Dec 2025 15:10:36 +0000

For now characters are defined as \uXXXX so it is not possible to encode character beyond BMP. Surrogate pairs is a common way to encode such characters but LispReader explicitly throws when it sees it - https://github.com/clojure/clojure/blob/master/src/jvm/clojure/lang/LispReader.java#L1217-L1218

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

Thu, 27 Nov 2025 12:15:33 +0000

Right now double colon is allowed only when used as a start of not empty identifier prefix. I wonder is there some explanation why it is forbidden anywhere else?

I found original commit, where this was introduced.
https://github.com/clojure/clojure/commit/005ea1b5f96c5bb762e155032a865e29ad71bcf3

But commit message has no explanation why it allows only non-repeating colon

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

Sat, 22 Nov 2025 17:12:47 +0000

user=> (clojure.edn/read-string "777/2") ;; no surprises
777/2
user=> (clojure.edn/read-string "0777/2") ;; wait, 0777 supposed to be 511
777/2
user=> (clojure.edn/read-string "0x777/2") ;; hexadecimal suddenly throws
Execution error (NumberFormatException) at user/eval175 (REPL:1).
Invalid number: 0x777/2
user=> (clojure.edn/read-string "32r777/2") ;; radix throws as well
Execution error (NumberFormatException) at user/eval177 (REPL:1).
Invalid number: 32r777/2
user=> (clojure.edn/read-string "777N/2") ;; same for BigInt
Execution error (NumberFormatException) at user/eval181 (REPL:1).
Invalid number: 777N/2

Inconsistent part here is octal integer numerator form. I would expect it to fail the same way as the rest of this list but not to silently drop leading zero and turn to not octal form at all.

Second part of the question is: Why other forms throws at all?

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

Thu, 20 Nov 2025 14:57:19 +0000

According to edn-format/edn specification

A reader should not call user-supplied tag handlers during the processing of the element to be discarded.

But with clojure.edn/read and its derivatives execute provided reader functions under discard tag:

user=> (clojure.edn/read-string {:readers {'foo (fn [val] (prn "!!!") val)}} "#_ #foo [1 2 3]")
"!!!"
Execution error at user/eval216 (REPL:1).
EOF while reading

The same happen with clojure.core/read and its derivatives:

user=> (binding [*data-readers* {'foo (fn [val] (prn "!!!") val)}] (read-string "#_ #foo [1 2 3]"))
"!!!"
Execution error at user/eval146 (REPL:1).
EOF while reading

I understand that Clojure' reader does not provide explicit description of what is executed during reading out form to be discarded except "The form following #_ is completely skipped by the reader." but I think it is worth to mention that here.

After realisation that this post is not qualifies as "ask"

To summarize:
Is this a bug in clojure edn specification implementation?
Is the edn specification no longer accurate?

.pow bigdec vs bigint

Sat, 26 Jul 2025 09:15:29 +0000

Consider this:

user> (.pow (bigdec 2) 3)
8M

user> (.pow (bigint 2) 3)
Execution error (IllegalArgumentException) at foo/eval10898 (REPL:1093).
No matching method pow found taking 1 args for class clojure.lang.BigInt

Is that an intentional choice in the language?

Note that this works:

user=> (.pow (biginteger 2) 3)
8
user=> (type (.pow (biginteger 2) 3))
java.math.BigInteger

Except the type is not clojure.lang.BigInt, but java.math.BigInteger, which are different types.

Associative destructuring with if-let

Sat, 07 Jun 2025 17:21:45 +0000

Hello,

I'm surprised by the result of this code :

(if-let [{errors :errors} {}]
    errors
    true) => nil

I would have expected the result to be 'true'.

As indicated by the result, 'errors' evaluates to nil, but still it's the 'then' arm of the 'if' that is evaluated.

The guide on destructuring state that "You can utilize destructuring anywhere that there is an explicit or implicit let binding.", so I'm a bit puzzled.

Please, enlighten me. Thanks !

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

Wed, 07 May 2025 12:29:34 +0000

I've noticed that clojure.edn parser will skip rest of the file if it manages to find the first valid token that will complete collection. For example:

;; demo.edn
{
 :foo 1
 :bar 2 }
 :baz 3 
}

with:

(require '[clojure.edn :as edn]
         '[clojure.java.io :as io])

(with-open [r (io/reader "demo.edn")]
  (edn/read (java.io.PushbackReader. r)))

user=> {:foo 1, :bar 2}

It will also ignore rest of the file when the file is clearly malformed:

{
 :foo 1
 :bar 2 }
xxxx yyyy }}}}} {{{{ ((
 :baz 3

it returns again:

user=> {:foo 1, :bar 2}

I was expecting it to throw EOF exception or at least '}' mismatch. Is this behavior by design or a possible bug?

Symbols with leading slashes

Thu, 17 Apr 2025 07:09:27 +0000

The Clojure reference states that a slash may occur only once in the middle of a symbol ( https://clojure.org/reference/reader#_symbols ), yet, the core symbol function permits symbols with leading slash non-conformingly ( https://clojuredocs.org/clojure.core/symbol#example-542692d5c026201cdc3270a0 ), and there has been the following thread here: https://ask.clojure.org/index.php/1510/allow-leading-slashes-in-unqualified-symbol-names .
Is there any more info available why only a single slash is allowed in the middle, and if either leading slashes may eventually be allowed or the symbol function be made conforming?

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

Fri, 21 Mar 2025 10:04:09 +0000

It's a rather frequent question where somebody gets a syntax error when trying to use something like {:keys [a b ...] :or {b a}}. The most recent instance: https://clojurians.slack.com/archives/C03S1KBA2/p1742549907988549

The error is as user-unfriendly as it gets and the behavior is also counter-intuitive if you don't happen to know the insides of destructuring and maps.

Perhaps it would make sense to alter the destructuring impl for when the default value in :or is not a primitive. So instead of being expanded to b (get map__1 :b a) it's expanded to b (get map__1 :b ::not-found) with a subsequent rebinding to b (if (identical? b ::not-found) a b) after all the other keys have already been extracted.

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

Tue, 16 Jan 2024 22:14:09 +0000

For comparisons (= < <= > >= ==) arity 3 and higher are much slower than doing e.g. (and (< a b) (< b c)). The arity 3 is in my research rather less common but still used in e.g. Manifold stream.clj [0] or rrb_vector rrbt.clj [1]. Arity 3 is idiomatic in places, where you compare lower and upper bound for a "variable". However, I don't think arity 4 and higher is used much in practical code. At least I haven't found any interesting instances of such a use.

An example implementation (based on the one currently in core) could be:

(defn <'
  "Returns non-nil if nums are in monotonically increasing order,
  otherwise false."
  {:inline         (fn [x y] `(. clojure.lang.Numbers (lt ~x ~y)))
   :inline-arities #{2}
   :added          "1.0"}
  ([x] true)
  ([x y] (. clojure.lang.Numbers (lt x y)))
  ([x y z] (and (<' x y) (<' y z)))
  ([x y z & more]
   (if (<' x y z)
     (if (next more)
       (recur y z (first more) (next more))
       (<' z (first more)))
     false)))

[0] https://github.com/clj-commons/manifold/blob/c3fc69066f3abba0b5ab0f4c2b1c4338bcc61d19/src/manifold/stream.clj#L978
[1] https://github.com/clojure/core.rrb-vector/blob/master/src/main/clojure/clojure/core/rrb_vector/rrbt.clj

Can Clojure support a byte-array literal?

Sun, 10 Dec 2023 02:44:53 +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?

Clojure reader fails to suppress cljs namespaced keywords

Fri, 03 Nov 2023 20:57:26 +0000

Reproducible test case:

(ns bug)
(require '[clojure.data.xml :as xml] #?@(:cljs [[clojure.data.xml.js.dom :as dom]]))
(def opts {:features #{:clj} :read-cond :allow})
(read-string opts "#?(:cljs {:a ::dom/Element})")
; Execution error at bug/eval30984 (REPL:534).
; Invalid token: ::dom/Element

Stack trace:

clojure.lang.Util/runtimeException (Util.java:221)
clojure.lang.LispReader/interpretToken (LispReader.java:412)
clojure.lang.LispReader/read (LispReader.java:305)
clojure.lang.LispReader/readDelimitedList (LispReader.java:1398)
clojure.lang.LispReader$MapReader/invoke (LispReader.java:1355)
clojure.lang.LispReader/read (LispReader.java:285)
clojure.lang.LispReader/access$900 (LispReader.java:41)
clojure.lang.LispReader$ConditionalReader/readCondDelimited (LispReader.java:1584)
clojure.lang.LispReader$ConditionalReader/invoke (LispReader.java:1659)
clojure.lang.LispReader$DispatchReader/invoke (LispReader.java:853)
clojure.lang.LispReader/read (LispReader.java:285)
clojure.lang.RT/readString (RT.java:1876)
clojure.core/read-string (core.clj:3817)
clojure.core/read-string (core.clj:3806)
bug/eval30984 (NO_SOURCE_FILE:534)
clojure.lang.Compiler/eval (Compiler.java:7194)

Real-world scenario:

Reading data.xml-0.2.0-alpha8/clojure/data/xml/spec.cljc errors in line 45: https://github.com/clojure/data.xml/blob/v0.2.0-alpha8/src/main/resources/clojure/data/xml/spec.cljc#L45

Note that stack trace is different there:

; Caused by: clojure.lang.ExceptionInfo: [line 45, col 28] Invalid keyword: ::dom/Element. {:type :reader-exception, :ex-kind :reader-error, :file nil, :line 45, :col 28}
; 	at clojure.tools.reader.impl.errors$throw_ex.invokeStatic(errors.clj:34)
; 	at clojure.tools.reader.impl.errors$throw_ex.doInvoke(errors.clj:24)
; 	at clojure.lang.RestFn.invoke(RestFn.java:442)
; 	at clojure.tools.reader.impl.errors$reader_error.invokeStatic(errors.clj:40)
; 	at clojure.tools.reader.impl.errors$reader_error.doInvoke(errors.clj:36)
; 	at clojure.lang.RestFn.invoke(RestFn.java:516)
; 	at clojure.tools.reader.impl.errors$throw_invalid.invokeStatic(errors.clj:97)
; 	at clojure.tools.reader.impl.errors$throw_invalid.invoke(errors.clj:96)
; 	at clojure.tools.reader$read_keyword.invokeStatic(reader.clj:358)
; 	at clojure.tools.reader$read_keyword.invoke(reader.clj:344)
; 	at clojure.tools.reader$read_STAR_.invokeStatic(reader.clj:935)
; 	at clojure.tools.reader$read_STAR_.invoke(reader.clj:917)
; 	at clojure.tools.reader$read_delimited.invokeStatic(reader.clj:198)
; 	at clojure.tools.reader$read_delimited.invoke(reader.clj:191)
; 	at clojure.tools.reader$read_list.invokeStatic(reader.clj:209)
; 	at clojure.tools.reader$read_list.invoke(reader.clj:205)
; 	at clojure.tools.reader$read_STAR_.invokeStatic(reader.clj:935)
; 	at clojure.tools.reader$read_STAR_.invoke(reader.clj:917)
; 	at clojure.tools.reader$read_delimited.invokeStatic(reader.clj:198)
; 	at clojure.tools.reader$read_delimited.invoke(reader.clj:191)
; 	at clojure.tools.reader$read_list.invokeStatic(reader.clj:209)
; 	at clojure.tools.reader$read_list.invoke(reader.clj:205)
; 	at clojure.tools.reader$read_STAR_.invokeStatic(reader.clj:935)
; 	at clojure.tools.reader$read_STAR_.invoke(reader.clj:917)
; 	at clojure.tools.reader$read_suppress.invokeStatic(reader.clj:451)
; 	at clojure.tools.reader$read_suppress.invoke(reader.clj:447)
; 	at clojure.tools.reader$match_feature.invokeStatic(reader.clj:474)
; 	at clojure.tools.reader$match_feature.invoke(reader.clj:458)
; 	at clojure.tools.reader$read_cond_delimited$fn__8556.invoke(reader.clj:485)
; 	at clojure.tools.reader$read_cond_delimited.invokeStatic(reader.clj:480)
; 	at clojure.tools.reader$read_cond_delimited.invoke(reader.clj:477)
; 	at clojure.tools.reader$read_cond.invokeStatic(reader.clj:522)
; 	at clojure.tools.reader$read_cond.invoke(reader.clj:506)
; 	at clojure.tools.reader$read_dispatch.invokeStatic(reader.clj:72)
; 	at clojure.tools.reader$read_dispatch.invoke(reader.clj:68)
; 	at clojure.tools.reader$read_STAR_.invokeStatic(reader.clj:935)
; 	at clojure.tools.reader$read_STAR_.invoke(reader.clj:917)
; 	at clojure.tools.reader$read.invokeStatic(reader.clj:988)
; 	at clojure.tools.reader$read.invoke(reader.clj:961)

Location data on all IObj

Wed, 20 Sep 2023 14:02:59 +0000

Only lists carry location data, even though most non-primitives implement IObj. Is there a reason for this? Would there be interest in adding location data to all IObj objects at read time?

user=> (meta '(1 2 3))
{:line 1, :column 8}
user=> (meta 'abc)
nil

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

Tue, 12 Sep 2023 15:50:14 +0000

When setting *default-data-reader-fn* to tagged-literal (as suggested in https://clojure.org/reference/reader#_default_data_reader_function) in a REPL like so:

user=> (set! *default-data-reader-fn* tagged-literal)

As advertised, the REPL can now read unknown tagged literals, e.g.:

user=> #foo 123
#foo 123

However, it fails when embedded in an expresson like so:

user=> (prn #foo 123)
Syntax error compiling fn* at (REPL:1:1).
Can't embed object in code, maybe print-dup not defined: clojure.lang.TaggedLiteral@34b5d34f

The hint in the error message works indeed, so when I provide:

user=> (defmethod print-dup clojure.lang.TaggedLiteral [tl w] (print-method tl w))

The REPL can now successfully read and eval the previous expression:

user=> (prn #foo 123)
#foo 123
nil

Should the print-dup implementation for clojure.lang.TaggedLiteral perhaps be provided by default?

Numeric keywords work but not numeric names in qualified keywords?

Fri, 27 Jan 2023 14:40:36 +0000

I've read that the Clojure reader allows reading of numeric keywords because it would cause breaking changes in some libraries to change it, so it seems keywords were not intended to be used in that way. However, is there a breaking reason to not allow the name part of a qualified keyword to be numeric? Since numeric keywords are already being used/allowed?

Use-Case:

I've been playing with modeling in Datomic which encourages namespaced things (that aren't really namespaced) and went with enums for US State FIPS codes since that's what we work with over state names and don't need more than that, i.e., :state/01

This works

(name :01) 
=> "01"

But this doesn't

(name :state/01)
=> Invalid token: :state/01

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

Thu, 08 Dec 2022 22:11:18 +0000

My code :

(defn loadData [filename]
(with-open [rdr (io/reader filename)]

(doseq [line (line-seq rdr)
        :let [ [id & data]
              (clojure.string/split line #"\|")] ]
            [
                (Integer/parseInt id) 
                data 
              ])
  
  ))

My file's content:

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

How do I get this function to return a list like :
{
{1, Xxx, info1, 222-2222}
{2, Yyy, info2, 333-3333}
{3, Zzz, info3, 444-4444}
}

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

Thu, 08 Dec 2022 16:50:28 +0000

= has a single arity returning true. Should it also have a 0 arity returning true as well?

This would be in line with the results of (and), (or), (every? odd []). And would make (apply = coll) safe in all cases, even when coll was empty.

From slack:
> Agreed - I had an #(->> xs ... (apply =)) in a fdef spec and it was failing in the case when xs is empty, forcing me to write a more verbose function.

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

Thu, 01 Dec 2022 11:51:35 +0000

Hello! I'm sorry if this is the wrong forum to start a thread like this, but I am new to Clojure/lisps in general and thought I would take this year's Advent of Code (2022) as an opportunity to challenge myself to learn a bit.

So I've started Day 1 and solved the problem (in essence, Given a long list of double space separated numbers, find the largest sum amongst them) but with what looks like the most inelegant thrashing of how one might approach the problem in Clojure.

For example, the answer for the following would be 300

My solution is as follows, and I am wondering primarily:

Is this a reasonable approach to the problem, as a beginner, what am I missing out on that would be more elegant.
How does one even format a line like this?

(Spoiler below, in case anyone else is interested in the challenge)

(require '[clojure.string :as str])

(reduce max (map (fn [x] (reduce + (map #(Integer/parseInt %) (str/split x #"\n")))) (str/split (slurp "./input-1.txt") #"\n\n")))

I'm hoping, time permitting, to be able to continue this journey through the month so hopefully I'm able to as the challenges do become quite complicated even for languages I'm familiar with, but I can already say the REPL is really a wonderful thing.

Suggestion: allow docstrings in defonce like in def

Sat, 29 Oct 2022 00:58:01 +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.

Read-time evaluation of macros causes errors

Tue, 11 Oct 2022 04:00:39 +0000

Read-time evaluation of functions work as expected. For instance, submitting #=(+ 1 1) to the REPL will indeed return 2. However, read-time evaluation forms such as (if true 1 0) will produce an error. The errors reported are not consistent across macros and special forms.

#=(if true 1 0)
;;=> Can't resolve if
#=(let [] nil)
;;=> Wrong number of args (2) passed to: clojure.core/let

Is this expected behavior? Languages like Common Lisp do not produce errors in this scenario--e.g. the code #.(if t 1 0) returns 1.

improve syntax errors on tagged-literals

Wed, 28 Sep 2022 13:24:40 +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

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

Mon, 26 Sep 2022 16:46:09 +0000

It's happen when i load the huqsql namespace into nREPL and then the error is appears to be something like this :

Syntax error (FileNotFoundException) compiling at (src/db_examples/hugsql.clj:1:1).
Could not locate hugsql/core__init.class, hugsql/core.clj or hugsql/core.cljc on classpath.

dependencies :

[[org.clojure/clojure "1.10.1"]
             [seancorfield/next.jdbc "1.1.613"]
             [org.postgresql/postgresql "42.2.8"]
             [com.layerware/hugsql "0.5.3"]
             [hugsql-next-jdbc "0.1.3"]]

the namespace :

(ns db-examples.hugsql

(:require [db-examples.core :refer [db]]
            [next.jdbc :as jdbc]
            [hugsql.core :as hugsql]))

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

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

Sat, 25 Jun 2022 01:27:29 +0000

I open a file, type in (map prn (range 2)) then save the file and execute clojure file.clj.
This produces no output.
I then execute clojure and type in (map prn (range 2)).
This produces output.

Is there some kind of "feature" of clojure that discards code within for and map if the result is not used when you run it on a file?
If that is the case, presumably it should give an error or at least a warning that there is dead code that it is discarding.

Has middle of sequence &rest destructuring been considered?

Mon, 20 Jun 2022 13:23:18 +0000

Currently, Clojure allows for destructuring patterns that contain &rest arguments:

user=> (let [[a b & c] (range 5)] [a b c])
[0 1 (2 3 4)]

Python allows for the same, but also for placing the so-called catch-all in the front and middle position as well (PEP description):

>>> a, *b, c = range(5)
>>> a
0
>>> c
4
>>> b
[1, 2, 3]

Has similar been considered for Clojure? Could look like this:

user=> (let [[a & b c] (range 5)] [a b c])
[0 (1 2 3) 4]

I feel like this would be doable with how the core functions destructure currently works, but it’s possible I don’t know some subtlety.

Why i get different result on the same sequence?

Mon, 13 Jun 2022 20:21:16 +0000

(= (map :name (mapify (parse (slurp filename)))) '("Edward Cullen" "Bella Swan" "Charlie Swan" "Jacob Black" "Carlisle Cullen" "Joni balap"))
=> true

(clojure.string/includes? (map :name (mapify (parse (slurp filename)))) "Joni")
=> false

(clojure.string/includes? '("Edward Cullen" "Bella Swan" "Charlie Swan" "Jacob Black" "Carlisle Cullen" "Joni balap") "Joni")
=> true

atom value different results

Fri, 03 Jun 2022 20:19:02 +0000

Hi,

(def cnt (atom 0))
(defn up[] (swap! cnt #(inc %)))
(defn down[] (swap! cnt #(dec %)))
(defn shift-by[offset] (swap! cnt #(+ % offset)))
(dotimes [_ 10] (up))
(println "cnt up => " @cnt)
(loop [i 0] (if (< i 10) (do (down)(recur (inc i)))))
(println "cnt down => " @cnt)
(def cnt' (for[i (range 5)] (shift-by i)))
(println "cnt shift1 => " @cnt)
(println "cnt' => " cnt')
(println "cnt shift2 => " @cnt)

cnt up => 10
cnt down => 0
cnt shift1 => 0
cnt' => (0 1 3 6 10)
cnt shift2 => 10

why is shift1 shows 0 and shift2 show 10?

Regards,
Daniel

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

Fri, 22 Apr 2022 16:42:02 +0000

Hello dear Clojurians!
What is the difference between "keyword" and "atom"?
Sorry, I'm a total newbie :-)

java interop, property same name as object

Fri, 11 Mar 2022 14:37:43 +0000

Hi all,

java pubilc class A has public proprety int a; when (def a(A.)) and then (.a a) the error A (wrong name :a) is shown.

Why is that?

[edit]

// silly example to demonstrate access patterns to A from clojure

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 -cp "."
user => (import A)
user => (def a (A.))
user => (def x (A.))
user => (def a1 (A.))
user => (.a a1)
1
user => (.a x)
1
user => (.a a)
Execution error (NoClassDefFoundError) at java.lang.ClassLoader/defineClass1 (ClassLoader.java:-2).
A (wrong name: a)

;; why a is not allowed?

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

Fri, 21 Jan 2022 18:18:24 +0000

The if-not macro is implemented as:

(defmacro if-not
  "Evaluates test. If logical false, evaluates and returns then expr, 
  otherwise else expr, if supplied, else nil."
  {:added "1.0"}
  ([test then] `(if-not ~test ~then nil))
  ([test then else]
   `(if (not ~test) ~then ~else)))

The first form expands to the second, and the second uses not, so if I simplify by removing docs and the other arity, we effectively get:

(defmacro if-not
  [test then else]
  `(if (if ~test false true) then else))

This seems like more work than just reversing the forms. I had assumed that this would instead be:

(defmacro if-not
  "Evaluates test. If logical false, evaluates and returns then expr, 
  otherwise else expr, if supplied, else nil."
  {:added "1.0"}
  ([test then] `(if-not ~test ~then nil))
  ([test then else]
   `(if ~test ~else ~then)))

I appreciate that it's not a big deal, but is there a reason for using not and not just inverting the forms?

PS. I believe this question may have been asked before, but I’ve been searching ask.clojure and can’t find it.

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

Mon, 22 Nov 2021 14:29:20 +0000

I thought Clojure automatically loads namespaces for vars used to read tagged literals in the source code, but apparently it isn't.

Given a library that defines data_readers.clj with following content:

{foo/bar my.library.foo/bar
 foo/baz my.library/baz}

An attempt to read #foo/bar [1 2 3] will result in this exception:

Syntax error reading source at (REPL:1:69).
Attempting to call unbound fn: #'my.library.foo/bar

To avoid this exception you need to require the library namespace before using reader tags.

It would be more convenient to be able to use library reader tags just by adding it to the classpath without explicit require step.

I don't know why it's made this way...

If the reasoning is clojure.core startup time, perhaps the actual load of the var ns might happen at the first tagged literal read time?
If the reasoning is security implications of unexpected code execution, maybe the behavior of requiring data reader namespaces could be configured with *read-eval*?

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

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

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

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

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

Here are some tests to run:

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

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

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

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

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

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

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

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

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

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 %))

How to access string character values in a map

Wed, 14 Apr 2021 17:35:03 +0000

I am working my way through a roman numerals clojure exercise.
I have
(def roman-numerals {"M" 1000 "D" 500 "C" 100 "L" 50 "X" 10 "V" 5 "I" 1})
and I'd like to convert let's say "XVI" to numbers - as a start. But

(map #(println %) (sequence "XIV"))
prints
`X
(nilI
nilV
nil)`

and

(map #(get roman-numerals %) (sequence "XIV"))
produces
(nil nil nil)

How can I get map to use the actual characters out of the sequence?

(sequence "XIV") => (\X \I \V)

http-kit authorization with api-key

Wed, 07 Apr 2021 11:07:39 +0000

I need to make an API call with http-kit in Clojure where it uses API-Key as authorization. That is, in Postman, you would usually have the option to add an api-key, api-value and the option to add it to header or query-params.

I know the following would be the way to go in case of basic-auth:

{:url "<api-url>"
 :method :post
 :headers {"Content-Type" "application/json"}
 :basic-auth [<username> <password>]
 :body <body>)}

I need to make an API call with http-kit in Clojure where it uses API-Key as authorization. That is, in Postman, you would usually have the option to add an api-key, api-value and the option to add it to header or query-params.

I know the following would be the way to go in case of basic-auth:

{:url "<api-url>" :method :post :headers {"Content-Type" "application/json"} :basic-auth [<username> <password>] :body <body>)}

But a similar variation isn't working with api-key version. So far, I have tried:

{:basic-auth [<api-key> <api-value>]}

{:query-params {<api-key> <api-value>}}

{:query-params {:key <api-key>, :value <api-value>}}

{:headers {"Content-Type" "application/json", 
                    <api-key> <api-value>}

{:api-key [<api-key> <api-value>]}

{:api-key {<api-key> <api-value>}

and other variations, but it doesn't seem to be working.

Note:
- The authorization works on postman but I couldn't test the full api call there because the body is too long and too complex to copy, and the authorization isn't working from the application.
- I keep getting a 401 error with all these different combinations, and some give typeerrors depending on where in the request they're placed.
- The documentation isn't really useful. Here is the link.

How to draw expression tree for function definition

Thu, 11 Mar 2021 20:25:29 +0000

Hi. As I'm learning clojure, I decided to draw a expression tree for my factorial code.

However, It seems like using (2) defn or (1) def and fn doesn't generate a nice looking expression tree.

So I've come up with (3) mydef which reveals the structure of a function and its argument. Drawn in the form of expression tree, this makes sense.

My question is:
1) Does (1) and (2) actually makes more sense?
2) is there a reason that function definition is not written like (3) mydef?

Here is the link to the diagram if anyone wants to use it:
https://drive.google.com/file/d/1hUnifN8GM5wGr9r8lE1jgCPqU4zH8iYE/view?usp=sharing

Problem using numbers as keywords

Sun, 21 Feb 2021 13:42:41 +0000

In Clojure 1.10.1 using numbers in qualified keywords results in a Syntax error

user> :ns/1
Syntax error reading source at (REPL:136:1).
Invalid token: :ns/1

I can however construct it using keyword

users> (keyword "ns" "1")
:ns/1

My problem is that the second form is not a legal test expression to use in a case statement.

Clojure Q&A - Recent questions in Syntax and reader

destructuring with :keys! and :or

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

Syntax-quoted lists can return nil, differs from ClojureScript

`eval` using functions with metadata

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

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

Aliased namespace in tagged literal

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

[clojure.edn] Leading zeros in numbers

Support characters beyond basic multilingual plane

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

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

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

.pow bigdec vs bigint

Associative destructuring with if-let

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

Symbols with leading slashes

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

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

Can Clojure support a byte-array literal?

Clojure reader fails to suppress cljs namespaced keywords

Location data on all IObj

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

Numeric keywords work but not numeric names in qualified keywords?

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

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

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

Suggestion: allow docstrings in defonce like in def

Read-time evaluation of macros causes errors

improve syntax errors on tagged-literals

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

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

Has middle of sequence &rest destructuring been considered?

Why i get different result on the same sequence?

atom value different results

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

java interop, property same name as object

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

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

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?

How to access string character values in a map

http-kit authorization with api-key

How to draw expression tree for function definition

Problem using numbers as keywords

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?