Clojure Q&A - Recent questions and answers in Syntax and reader

Answered: `eval` using functions with metadata

Mon, 01 Jun 2026 16:31:28 +0000

You're eval'ing + to a function object there when it seems like you should be staying in symbol land:

user=> (eval (list (with-meta '+ {}) 1 2))
3

A function object itself is not Clojure data (other than opaquely as an object). When working symbolically, you should stay in symbols.

There are some places where the compiler uses an escape hatch of print + read-eval (#=) to recover custom types (sorted maps and sets), but I'd consider that implementation details, not something you as a user should be doing generally.

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

Mon, 12 Jan 2026 22:26:24 +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"

Answered: [clojure.edn] Leading zeros in numbers

Mon, 15 Dec 2025 20:05:17 +0000

Leading zeroes in Clojure should largely follow the lead of Java when the reference is unclear:

Long - multiple leading 0s allowed, treated as octal
BigInteger - multiple leading 0s allowed, treated as decimal in Java BigInteger, octal in Clojure (this is a difference, but supported by the reader reference page)
Double - multiple leading 0s allowed in either whole number part of exponent, treated as decimal
BigDecimal - multiple leading 0s allowed, treated as decimal

With respect to edn, there are additional constraints - octal is not supported, and leading 0s not allowed in integers, but are allowed in decimal whole and exponents by my reading. I do not see support for your assertion "even for floats" - the constraint is listed only for integers).

Thus I would expect that any leading 0s in an integer (with or without N suffix) should be invalid, yet they are all read as octal. So that seems like a potential bug. Because clojure.edn is a superset of edn, you could potentially contend this is additive syntax/semantics beyond edn but seems a little confusing.

For floating points, by my reading, leading 0s in whole or exponent parts are allowed, so no issue or difference from Clojure or Java there afaict.

Answered: Aliased namespace in tagged literal

Thu, 11 Dec 2025 20:18:34 +0000

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

I reworded the title and problem as this slips into solution space (and I'm not sure that solution is even possible given the reader nature of the problem).

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

Tue, 09 Dec 2025 22:55:20 +0000

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

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

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

Tue, 02 Dec 2025 16:47:37 +0000

Don't know, sorry.

Answered: Support characters beyond basic multilingual plane

Tue, 02 Dec 2025 16:42:47 +0000

That line you linked is specifically for reading an individual character value (like \a) - as a single character it's not possible to represent both parts of a surrogate pair, so this seems correct (a Java char is an int).

However, you can use surrogate pairs in strings, which is how you would most commonly use them, and that works fine.

$  clj
Clojure 1.12.3
user=> "\ud83d\ude0d"
""

I believe surrogate pairs are not currently allowed in symbols or keywords, that's maybe something that could be extended in the future, but I haven't seen anyone looking for that yet.

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

Tue, 25 Nov 2025 20:22:21 +0000

This is definitely an appropriate thing to put on Ask Clojure and seems like a bug in the impl of the spec to me.

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

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

Tue, 25 Nov 2025 19:43:36 +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.

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

Tue, 12 Aug 2025 21:31:07 +0000

Yes, I use 3-arity inequality functions with some regularity, much like PostgreSQL's BETWEEN operator, I've also seen it used by others. I think the most frequent use case for this is in tests for me personally but some of these are inside ares that can get large, so I would appreciate a performance optimization.

I would also agree that 4+ arity is exponentially rarer than 3-arity (I've never seen it in practice, but I assume there's been at least one person who has done (apply > coll) at some point to check if a collection is sorted), but I have no data on this beyond anecdotal experience.

Answered: .pow bigdec vs bigint

Sat, 26 Jul 2025 18:51:35 +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.

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 !

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

Wed, 07 May 2025 12:52:47 +0000

It's by design, all according to the docstring of edn/read:

Reads the next object from stream [...]

You can read multiple times from the same stream to get all of the objects and to validate the whole file.

(with-open [r (io/reader "demo.edn")]
  (loop []
    (let [data (edn/read (java.io.PushbackReader. r))]
      (println "Got data" data)
      (recur))))
Got data {:foo 1, :bar 2}
Got data :baz
Got data 3
Execution error at user/eval3609 (form-init10153318817371430115.clj:3).
Unmatched delimiter: }

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

Answered: Can Clojure support a byte-array literal?

Sun, 10 Dec 2023 10:30:31 +0000

Unless I'm missing something, three years ago you have asked the same exact thing: https://ask.clojure.org/index.php/9567/possible-create-tagged-literal-reader-for-clojure-core-vec

Why create a new post? It'll only end up spreading the already thin attention this issue has. That's why posts here have votes.

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

Given that that other question has only one vote in 3 years, I'd say not that many people care for the maintainers to put it high enough in the priority list.

Answered: Clojure reader fails to suppress cljs namespaced keywords

Fri, 03 Nov 2023 21:37:59 +0000

Autoresolved keywords require namespace resolution (the main feature of the reader that requires external environment).

Because reader conditionals "read" all of the parts of the conditional, it is necessary that anything in the conditional is readable in every platform, and thus autoresolved keywords in reader conditionals should not rely on conditional namespaces.

This should be considered the expected behavior, so don't do that.

We have considered whether it would be possible to suspend autoresolved keyword resolution in the context of reader conditionals but it is somewhat tricky, and I don't think we're going to do that anytime soon.

Answered: Location data on all IObj

Thu, 21 Sep 2023 11:11:07 +0000

What problem are you trying to solve?

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

Thu, 14 Sep 2023 14:52:30 +0000

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

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

Mon, 30 Jan 2023 20:00:23 +0000

What does it mean to compare 0 things?

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

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

Thu, 08 Dec 2022 23:32:37 +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.

Answered: Suggestion: allow docstrings in defonce like in def

Sun, 30 Oct 2022 16:01:41 +0000

We have an old ticket for this that has been through several rounds of patches, it's actually surprisingly tricky to get right. :)

https://clojure.atlassian.net/browse/CLJ-1148

Answered: Read-time evaluation of macros causes errors

Tue, 11 Oct 2022 19:26:05 +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: improve syntax errors on tagged-literals

Thu, 29 Sep 2022 19:14:18 +0000

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

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

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

Sat, 25 Jun 2022 10:40:53 +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.

Answered: Has middle of sequence &rest destructuring been considered?

Mon, 20 Jun 2022 17:54:27 +0000

In what scenario would this be useful?

Answered: Why i get different result on the same sequence?

Tue, 14 Jun 2022 05:54:18 +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.

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

Wed, 08 Sep 2021 21:40:16 +0000

"Aside from being unable to extend IFn to strings and numbers" is kind of a critical thing. We don't own the types and adding those checks would have to be in the path of all function evaluation, so I think this is a non-starter.

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.

Function calls to generate docstrings?

Wed, 10 Feb 2021 05:36:58 +0000

I was curious if a function could be defined like the following:

(defn my-cli-func
  (docstr 
    :description "Some CLI function with complex args to do something cool"
    [["-p" "--port" :port "Port to listen for connections on"]])
  [args]
  "...")

The intention is that docstr could generate a docstring in a consistent format I can validate and such. That did not work as I get an error about where the Parameter declaration should be.

I'm guessing it could be done with a defn wrapper macro but probably not worth the hassle right now.

I was curious if there was a design decision to not allow meta programming there or if it's some kind of mechanical restriction due to the implementation.

can i bind in a for comprehension with a map?

Tue, 26 Jan 2021 19:09:50 +0000

(defn get-pins [observed]
  (let [num (count observed)
        keypad {\1 [1 2 4] \2 [2 1 5 3] \3 [3 2 6]
                \4 [4 1 5 7] \5 [5 2 6 8 4] \6 [6 3 5 9]
                \7 [7 4 8] \8 [8 5 9 0 7] \9 [9 6 8] \0 [0 8]}
        observed-map (zipmap [:a :b :c :d] (map keypad observed))]
    (case num
      1 (for [a (:a observed-map)]
          (str a))
      2 (for [a (:a observed-map)
              b (:b observed-map)]
         (str a b))
      3 (for [a (:a observed-map)
              b (:b observed-map)
              c (:c observed-map)]
         (str a b c))
      4 (for [a (:a observed-map)
              b (:b observed-map)
              c (:c observed-map)
              d (:d observed-map)]
         (str a b c d))
       "default")))