Clojure Q&A - Recent questions in Docs

It's difficult to figure out options I can pass to slurp function.

Fri, 27 Feb 2026 06:41:39 +0000

(doc slurp) says

clojure.core/slurp
([f & opts])
Opens a reader on f and reads all its contents, returning a string.
See clojure.java.io/reader for a complete list of supported arguments.

(doc clojure.java.io/reader) says

clojure.java.io/reader
([x & opts])
Attempts to coerce its argument into an open java.io.Reader.
Default implementations always return a java.io.BufferedReader.

Default implementations are provided for Reader, BufferedReader,
InputStream, File, URI, URL, Socket, byte arrays, character arrays,
and String.

If argument is a String, it tries to resolve it first as a URI, then
as a local file name. URIs with a 'file' protocol are converted to
local file names.

Should be used inside with-open to ensure the Reader is properly
closed.

I read the source code, and I was confused even more.

Reader docs say foo.bar is a qualified symbol but qualified-symbol? is false

Mon, 12 Jan 2026 21:44:25 +0000

The reader reference on clojure.org says "Symbols containing / or . are said to be 'qualified'." but qualified-symbol? is defined to return true if the argument is a "symbol with a namespace".

Almost every reference to a "qualified symbol" in the docs (on clojure.org) refers to a "namespace-qualified symbol" or a "fully-qualified symbol" (also with a namespace).

The only other type of "qualified symbol" mentioned is on the evaluation page where it refers to a "package-qualified symbol" for a Java class name.

I suggest changing that original sentence to read "Symbols containing / are said to be 'namespace-qualified' or 'fully-qualified'. Symbols containing . are said to be 'package-qualified' if they identify a Java class name." or something similar.

Docstring clojure.edn/read-string is misleading

Thu, 20 Nov 2025 15:10:38 +0000

user=> (doc clojure.edn/read-string)
-------------------------
clojure.edn/read-string
([s] [opts s])
Reads one object from the string s. Returns nil when s is nil or empty.
Reads data in the edn format (subset of Clojure data):
http://edn-format.org

opts is a map as per clojure.edn/read

Note Returns nil when s is nil or empty.. But when called with opts without explicit :eof it throws EOF error

user=> (clojure.edn/read-string {} "")
Execution error at user/eval222 (REPL:1).
EOF while reading

And without options it returns nil as expected

user=> (clojure.edn/read-string "")
nil

Typo in clojure.zipper/zipper docstring

Mon, 27 Oct 2025 09:30:17 +0000

The docstring for clojure.zipper/zipper currently contains:

branch? is a fn that, given a node, returns true if can have
children, even if it currently doesn't.

which should be:

branch? is a fn that, given a node, returns true if it can have
children, even if it currently doesn't.

The docstring on empty? should perhaps not recommend using seq instead anymore

Fri, 17 Oct 2025 11:55:12 +0000

It seems the docstring on empty? is outdated, recommending to use seq to check for emptiness, even though nowodays empty? may be much faster (on counted collections):

(defn empty?
  "Returns true if coll has no items. To check the emptiness of a seq,
  please use the idiom (seq x) rather than (not (empty? x))"
  {:added "1.0"
   :static true}
  [coll]
  (if (counted? coll)
    (zero? (count coll))
    (not (seq coll))))

":added" metadata missing from some new public functions in namespace clojure.java.process

Fri, 11 Apr 2025 16:29:23 +0000

These functions in the namespace clojure.java.process are mentioned in the doc string for the namespace, and have doc strings, but do not have metadata {:added "1.12"} as do other new public docstring'ed functions in that namespace:

stdin
stdout
stderr
exit-ref

I did not find any other such functions anywhere else that are new in Clojure 1.12.0 vs. Clojure 1.11.1.

Can we add metaphors/analogies for functional closures in Clojure to the docs please?

Thu, 20 Mar 2025 14:13:58 +0000

Hi,
Having been a longtime happy and satisfied user of Clojure I realized that there is very little to introduce someone new to Clojure to closures where functions [like vehicles] are passed in with opaqueness to their variables [like passengers] to another function. I think this is probably a stumbling block for many beginners and might even, unfortunately, discourage people from adopting the language without further explanation of this caveat. I think many programmers will also disagree with my assessment because they have "closure eyes" and can transparently understand passing functions around as first-class-citizens so-to-speak.

I propose that we amend the documentation to explicitly mention that closures are basically like vehicles or cars with passengers.

the fact that not everything is transparent to the top level function call is something non-obvious

(defn make-adder [x]
 (fn [y] (+ x y)))

(def add5 (make-adder 5))
 (add5 10) ;; Returns 15

In this example:

make-adder is like a vehicle factory. When you call it with 5, it creates a new vehicle.
This new vehicle (the returned function) has a permanent passenger: the value 5 is sitting in the x seat.

There's one empty seat (y) that you can fill when you drive the vehicle (call the function).

When you call (add5 10), you're putting 10 in the y seat and driving the vehicle.

Inside, the passengers interact: x (which is 5) and y (which is 10) are added together.

How REPLs and Closures Intertwine
The REPL (Read-Eval-Print-Loop) and closures interact in interesting ways:

Creation and Persistence:
When you define (def add5 (make-adder 5)) in the REPL, you're parking a vehicle (with 5 already inside) in your garage with the name "add5". This vehicle persists between REPL evaluations.
Inspection Limitations:
In the REPL, you can see that add5 is a function, but you can't directly inspect who's sitting inside it. If you evaluate add5, you'll just see something like #function[user/make-adder/fn--123].
Usage in REPL:
You can use the closure by calling it: (add5 10). The REPL will evaluate this by driving the vehicle with 10 in the y seat, and print the result (15).

Docstring typos in clojure.core/bytes, chars, shorts

Thu, 06 Mar 2025 06:54:53 +0000

The docstring of clojure.core/bytes has a minor typo:

"Casts to bytes[]"

which should read byte[]; similarly for the docstrings of chars and shorts.

Given the new array class syntax in Clojure 1.12 perhaps these should be updated to read byte/1, float/1 etc. instead of using Java style syntax?

Found some typos in clojure.core, how to contribute a patch?

Sun, 29 Sep 2024 14:22:30 +0000

Hi,

For example, if is mispelled in defonce docs:

(defmacro defonce
  "defs name to have the root value of the expr iff the named var has no root value,
  else expr is unevaluated"

I've already signed the Clojure Contributor Agreement.

Is edn-format.org supposed to be online?

Wed, 18 Sep 2024 09:29:07 +0000

The documentation of clojure.edn/read references http://edn-format.org. However, it is offline.

A Whois query results in name servers like ns1170.dns.dyn.com. When doing the dig query dig @dns.google.com edn-format.org NS, I got "Network Error" messages.

Maybe https://github.com/edn-format/edn is supposed to replace edn-format.org. In this case, updating the api reference would be good.

In addition, https://clojuredocs.org/clojure.edn references edn-format.org as well.

Comparison ops "Return non-nil if..., otherwise false"

Wed, 31 Jul 2024 01:41:56 +0000

The docstring of < (and others) says:

Returns non-nil if nums are in monotonically decreasing order,
otherwise false.

That seems a bit weird since a) they return either true or false and b) false is "non-nil" so it seems misleading / unhelpful.

What is the history for saying "non-nil" rather than true?

Add example to namespaced maps for :_/foo functionality

Wed, 03 Jul 2024 01:17:02 +0000

In the section for namespaced map syntax, the middle bullet point mentions that :_/foo will treat the keyword as not having the map's current namespace, allowing for including un-namespaced keys in a namespaced map. The example given doesn't include this behavior, which has lead many (me, the entirety of the Discljord server, and I suspect many more in the wider clojure world) to not know about this behavior.

I think it would be helpful to include it in the example, making the behavior explicit and obvious. Something like:

For example, the following map literal with namespace syntax:

#:person{:_/species "Human"
         :first "Han"
         :last "Solo"
         :ship #:ship{:name "Millennium Falcon"
                      :model "YT-1300f light freighter"}}

is read as:

{:species "Human"
 :person/first "Han"
 :person/last "Solo"
 :person/ship {:ship/name "Millennium Falcon"
               :ship/model "YT-1300f light freighter"}}

I've signed the CA and can open an PR if it's acceptable.

Missing documentation for `:while` modifier of `for` and `doseq`

Mon, 01 Jul 2024 13:56:08 +0000

I believe the for and doseq documentation (at least docstrings) fail to explain the semantics of the :while modifier. The existence is documented, but not the behavior.

I would like to request that the doctoring be updated, especially since it behaves in what I believe is a reasonable but counter-intuitive way. I believe a reasonable person would expect that :while false would trigger the for or doseq to exit; however it does not. Rather it causes the inner-most loop containing the :while to exit, but most notably the outer loops continue to iterate.

Another discussion of this can be found here: clojurians

Documentation on alternative radix/0-prefixed numbers

Tue, 30 Apr 2024 16:22:09 +0000

The data structures section on numbers (https://clojure.org/reference/data_structures#Numbers) doesn't mention any of the alternate radix numbers. Reading the code in LispReader is challenging, I'm not exactly sure how it should work. Is there another place this is documented? If not, can the various ways be documented?

Here's what I've discovered from reading the regex and code, not sure which of this is intentional or undefined behavior:

0      ; 0
+0     ; 0
+0N    ; 0N
1      ; 1
-1     ; -1
123    ; 123
123N   ; 123N
0x1A   ; 26
0x1AN  ; 26N
012    ; 10
012N   ; 10N
12r1   ; 1
12r1N  ; fails
12r2a  ; 34
12r2aN ; fails

Does `:exclude` need to be added to https://clojuredocs.org/clojure.core/require ?

Tue, 13 Feb 2024 19:29:06 +0000

https://clojuredocs.org/clojure.core/require makes no mention of :exclude but this seems to work as it appears:

(require '[clojure.set :refer :all :exclude [join rename]])

`hash-map` without arguments returns an array map, despite the docstring

Sun, 11 Feb 2024 20:38:56 +0000

The docstring of hash-map states that it returns a hash map.
However, there's an arity with no arguments that returns an empty array map.

So there's a discrepancy between the docs and the impl.

Typo in the release notes for 1.12.0-alpha6

Fri, 09 Feb 2024 00:51:06 +0000

This under Array Class Symbols

Clojure supporst class symbols

should be

Clojure supports class symbols

Dedupe doesn't mention statefullness in docstring

Mon, 22 Jan 2024 12:22:44 +0000

Unlike all other core functions which can return a stateful transducer, dedupe doesn't mention this in its docstring. E.g. distinct, drop-while etc. all say:

Returns a stateful transducer when no collection is provided.

But dedupe just says:

Returns a transducer when no collection is provided.

clojure.math/scalb docstring error

Sat, 11 Nov 2023 13:08:46 +0000

The docstring for scalb links to the documentation for nextDown, presumably just a mistake.

It links here: https://docs.oracle.com/javase/8/docs/api/java/lang/Math.html#nextDown-double-

But should link here: https://docs.oracle.com/javase/8/docs/api/java/lang/Math.html#scalb-double-int-

clojure.math/floor docstring error

Mon, 30 Oct 2023 12:55:24 +0000

In the docstring for clojure.math/floor it says:

If a is less than zero but greater than -1.0 => -0.0

but that's obviously not true:

(math/floor -0.3)
;; => -1.0

I guess it was intended to add that line to the docstring of clojure.math/ceil but added it to floor by mistake?

update-vals documentation string has a typo

Fri, 15 Sep 2023 22:12:07 +0000

(doc update-vals)
-------------------------
clojure.core/update-vals
([m f])
  m f => {k (f v) ...}

  Given a map m and a function f of 1-argument, returns a new map where the keys of m
  are mapped to result of applying f to the corresponding values of m.

Says "...returns a new map where the >>>keys<<< of m are mapped to...". This should be "values," not "keys." Probably a cut/paste holdover from the update-keys doc string.

The new add-lib etc fns do not make it clear they shell out to the CLI

Thu, 24 Aug 2023 21:26:35 +0000

https://clojure.github.io/clojure/branch-master/clojure.repl-api.html#clojure.repl.deps

Neither the ns docstring nor the individual function docstrings explain that they shell out to the CLI and that you need a recent version of the CLI installed.

Having an old CLI might produce this error:

Execution error (ExceptionInfo) at clojure.tools.deps.interop/invoke-tool (interop.clj:49).

Which might be enough of a clue to lead people to:

https://clojure.github.io/clojure/branch-master/clojure.tools.deps.interop-api.html

A more informative error message might help users debug this but expanding those docstrings to clarify that the functions invoke the CLI as a subprocess would also help.

Links to EPL license are now broken

Wed, 23 Aug 2023 17:16:20 +0000

Links such as https://github.com/clojure/clojure/blob/2a058814e5fa3e8fb630ae507c3fa7dc865138c6/test/clojure/test_clojure/protocols.clj#L3C33-L3C79 direct one to a 404 page.

The `keyword` and `symbol` docstrings don't mention that using `"a/b"` as its only argument is valid

Wed, 08 Feb 2023 16:53:38 +0000

The current docstrings:

clojure.core/keyword
([name] [ns name])
  Returns a Keyword with the given namespace and name.  Do not use :
  in the keyword strings, it will be added automatically.

clojure.core/symbol
([name] [ns name])
  Returns a Symbol with the given namespace and name. Arity-1 works
  on strings, keywords, and vars.

The arglists suggest that the first arity is to be used for simple idents only.
However, the underlying implementation explicitly handles the case when there's / in the value, and even the argument is named nsname:

static public Symbol intern(String nsname){
	int i = nsname.indexOf('/');
	if(i == -1 || nsname.equals("/"))
		return new Symbol(null, nsname);
	else
		return new Symbol(nsname.substring(0, i), nsname.substring(i + 1));
}

One example where some existing code relies on this behavior: transit-clj

Perhaps, the docstrings should be updated to reflect that?

Add example of clojure -Sdeps to Deps and CLI guide or reference

Tue, 04 Oct 2022 18:38:54 +0000

Testing libraries before adding them to a deps.edn file by using -Sdeps '{...}' is a frequent recommendation, but it's only mentioned in a single line in the Reference page.

I think it would be helpful if it (and the other flags) had examples with more detail about how they're used and why. Maybe something like:

-Sdeps - pass the config data on the command line

For example, instead of creating a new deps.edn file to experiment with a new library, you can use -Sdeps to pass in the :deps map to clojure:

$ clojure -Sdeps '{:deps {org.clojure/core.match {:mvn/version "1.0.0"}}}'
Clojure 1.11.1
user=> (require '[clojure.core.match :refer [match]])
nil

Document that distinct preserves ordering

Wed, 15 Jun 2022 17:24:25 +0000

Looking at the source of distinct in both Clojure and Clojurescript, it seems that the order of the first appearance of distinct elements is preserved. If this is a promise of distinct, it would be good have it documented in the doc string. I am personally relying on this behavior for sorting a collection of maps based on the order of which certain keys appear in the collection.

Documentation for `rationalize` is misleading

Sat, 02 Apr 2022 15:15:17 +0000

It says

returns the rational value of num

but the results of (rationalize 1.6) is 8/5 instead of expected 3602879701896397/2251799813685248. What kind of rounding is performed isn't documented.

doall docstring

Mon, 27 Dec 2021 14:38:37 +0000

The docstring for doall states:

...other than those needed to produce the first element in the seq ...

I believe this stems from the time before chunked seqs, and perhaps "first elements" would be more correct ?

Invoke Clojure with an argument

Mon, 27 Dec 2021 00:47:59 +0000

I have a problem that might be related to java interop & reflection. Researching the issue led me to the Clojure FAQ on illegal accesses. It says to add --illegal-access=debug. After half an hour, I still can't figure out how. This is an odd problem, but I honestly seem to be struggling at running the gauntlet of adding an argument. I looked at clj --help and the Deps and CLI Guide, but it is taking so much effort I must be missing a guide or page of documentation somewhere.

% clj -e "\*clojure-version\*"
{:major 1, :minor 10, :incremental 0, :qualifier nil}
% clj --illegal-access=debug
Exception in thread "main" java.io.FileNotFoundException: --illegal-access=debug (No such file or directory)
        at java.base/java.io.FileInputStream.open0(Native Method)
        at java.base/java.io.FileInputStream.open(FileInputStream.java:219)
        at java.base/java.io.FileInputStream.<init>(FileInputStream.java:157)
        at java.base/java.io.FileInputStream.<init>(FileInputStream.java:112)
        at clojure.lang.Compiler.loadFile(Compiler.java:7570)
        at clojure.main$load_script.invokeStatic(main.clj:452)
        at clojure.main$script_opt.invokeStatic(main.clj:512)
        at clojure.main$script_opt.invoke(main.clj:507)
        at clojure.main$main.invokeStatic(main.clj:598)
        at clojure.main$main.doInvoke(main.clj:561)
        at clojure.lang.RestFn.applyTo(RestFn.java:137)
        at clojure.lang.Var.applyTo(Var.java:705)
        at clojure.main.main(main.java:37)

I've also got a docker image running (FROM clojure:openjdk-18-tools-deps-1.10.3.1040-bullseye) that doesn't work either:

root@dd07c7fedc67:/app# clojure -e "\*clojure-version\*"
WARNING: Implicit use of clojure.main with options is deprecated, use -M
{:major 1, :minor 10, :incremental 3, :qualifier nil}
root@dd07c7fedc67:/app# clojure -M --illegal-access=debug
Execution error (FileNotFoundException) at java.io.FileInputStream/open0 (FileInputStream.java:-2).
--illegal-access=debug (No such file or directory)
Full report at:
/tmp/clojure-7987604327110923419.edn
root@dd07c7fedc67:/app# clojure -M -m clojure.main --illegal-access=debug
Execution error (NullPointerException) at clojure.main/main (main.java:40).
Cannot invoke "clojure.lang.IFn.applyTo(clojure.lang.ISeq)" because "f" is null
Full report at:
/tmp/clojure-17703419873584290207.edn

Typo in https://clojure.org/guides/tools_build

Sat, 04 Dec 2021 20:04:37 +0000

Hi all
I am afraid there is a typo in https://clojure.org/guides/tools_build

In the Compiled uberjar application build section the build.clj should read

...

(b/uber {:class-dir class-dir

       :uber-file uber-file
       :basis basis
       :main 'my.lib.main}))

currently reads :main my.lib.main (no apostrophe there)

This may be evident for experienced guys but it is a problem for beginners like me

Thanks!

requesting change to doc string in (doc take-while)

Tue, 09 Nov 2021 21:02:32 +0000

Requesting change to (doc take-while)

currently it says

clojure.core/take-while
([pred] [pred coll])
Returns a lazy sequence of successive items from coll while
(pred item) returns logical true. pred must be free of side-effects.
Returns a transducer when no collection is provided.

clojure.core/take-while
([pred] [pred coll])
Returns a lazy sequence of successive items from coll while
(pred item) returns logical true and stops at first false. pred must be free of side-effects.
Returns a transducer when no collection is provided.

This catches out people new to programing/clojure

see

https://stackoverflow.com/questions/69845947/why-is-take-while-returning-empty-sequence

clojure.java.api documentation mistaken example

Thu, 21 Oct 2021 12:32:27 +0000

In the current text of clojure.java.api, there is an text explaining that IFn can be passed to HOF.

Then an example is presented as "passing plus to read" but I think the example is actually passing inc to map.

This is the current text:

IFns can be passed to higher order functions, e.g. the example below passes plus to read:

IFn map = Clojure.var("clojure.core", "map");
IFn inc = Clojure.var("clojure.core", "inc");
map.invoke(inc, Clojure.read("[1 2 3]"));

Docstring for `=` could be made less ambiguous w.r.t. numbers

Sat, 28 Aug 2021 13:11:55 +0000

The current docstring of = says:
> compares numbers and collections in a type-independent manner

Which makes it sound like it compares numbers by value, checking whether dots on a number line coincide.

Whereas in reality:

user=> (= 1. 1)
false

The page at https://clojure.org/guides/equality#_summary explains why, but it would be nice to have that information in the docstring as well.

What do the metalanguage-style symbols on clojuredocs.org mean?

Sat, 19 Jun 2021 15:32:03 +0000

I want to know what the characters mean on the second lines of entries on https://clojuredocs.org.

For example, head on over to https://clojuredocs.org/clojure.core/prn.

The first line of that page is:

prn

The second line is:

(prn & more)

What does (prn & more) mean? How do I interpret that? In particular, how do I interpret the ampersand &?

The notation used here reminds me of the "metalanguage" Augmented Backus-Naur form (https://en.wikipedia.org/wiki/Augmented_Backus–Naur_form), used to express the grammar of a programming language, and of the usage guidance often given by help entries for programs.

However, I don't see any documentation anywhere of how to interpret this particular metalanguage, if that's even what's going on here.

I am especially wondering how to interpret the &.

If there is a page somewhere explaining this, I wish it were linked from every entry on https://clojuredocs.org.

Could `clojure.zip/next` docstring be misleading to some?

Tue, 11 May 2021 16:53:49 +0000

I’m wondering if the docstring for clojure.zip/next could be misleading to some, it reads:

Moves to the next loc in the hierarchy, depth-first. When reaching the
end, returns a distinguished loc detectable via end? If already at the
end, stays there.

Some people might assume, without more guidance, that the end of the zipper is the last node in the zipper and that calling next at that point will leave the zipper located at the last node.

As far I understand it (which may be not far), the Clojure zipper end state is hit when you’ve called next after the last node in the zipper, after which:

the zipper is no longer navigable or updatable.
you can still call root (or node which at this point is equivalent to root), next and end? but otherwise, I think, it is game over.

Some code to show behaviour:

(require '[clojure.zip :as czip])
(->> [1 2 3]
     czip/vector-zip
     (iterate czip/next)
     (take 10)
     (map (juxt czip/node czip/end?)))
;; => ([[1 2 3] false]
;;     [1 false]
;;     [2 false]
;;     [3 false]
;;     [[1 2 3] true]
;;     [[1 2 3] true]
;;     [[1 2 3] true]
;;     [[1 2 3] true]
;;     [[1 2 3] true]
;;     [[1 2 3] true])

The next docstring might want to talk more about what “end” is and what reaching the end state means. Maybe something like:

Moves to the next loc in the hierarchy, depth-first.
When reaching the end, which is after the last node, returns a distinguished loc detectable via end?. If already at the end, stays there.
When at end, valid calls are end?, next and root.

If the docstring is not the right place, maybe the zipper overview could elaborate?

Add warning about not using the ret-val of `assoc!` to the doc string

Fri, 23 Apr 2021 21:48:43 +0000

From https://github.com/clj-kondo/clj-kondo/issues/1258 :
Some of the functions on transients, specifically assoc! appears to be working even when not handling the return type:

user> (let [t (transient {})]
        (assoc! t :foo :bar)
        (persistent! t))
;; => {:foo :bar}
user>

This blows up when we reach more than 8 entries in the map:

user> (let [t (transient {})]
        (doseq [i (range 10)]
          (assoc! t (str i) i))
        (persistent! t))
;; => {"0" 0, "1" 1, "2" 2, "3" 3, "4" 4, "5" 5, "6" 6, "7" 7}
user>

This seems to hit both beginner and experienced clojure programmers from time to time,
so it might be worth adding a notice to the doc string.

Even though conj! (and perhaps the other fns on transients) seem to work without handling the return type, that might just be an implementation detail, so a warning might be in place there as well

Typo in Getting Started: /etc/man_dev.conf ➡ /etc/man_db.conf

Mon, 01 Feb 2021 02:57:27 +0000

The Getting Started instructions for Linux should refer to /etc/man_db.conf instead of /etc/man_dev.conf.

Which argument is which, for bit-shift-left and bit-shift-right?

Sun, 31 Jan 2021 16:30:04 +0000

The docstring for (bit-shift-left x n) says only "Bitwise shift left". It does not define either x or n.

Below the docstring is a link to the source code, but it does not immediately clear up the question, as it delegates to a method of clojure.lang.Number.

Suggestion: enhance the docstring along the lines of "Bitwise shift x left by n bits".

P.S. Does left mean more-significant everywhere nowadays? As Clojure gets implemented in JS and even stranger environments, could the docstring clarify whether Clojure's left and right have a specified mathematical significance (as the Java Language Specification does) or have host-dependent significance?

P.P.S. Likewise, bit-shift-right.

P.P.P.S. Likewise in the ClojureScript docstrings.

Is "port" inside core.asyn documentation same as a "chan"?

Tue, 29 Dec 2020 23:51:09 +0000

Inside the documentation for core.async, the identifier port is used as an input to some functions/forms. Is port the same as chan? Or is it an interface or a protocol implemented by chan?

Document how extend-type can be used to provide default protocol implementation

Sat, 19 Dec 2020 19:19:57 +0000

In ClojureScript one can provide default protocol implementations as follows:

(extend-type default 
  AProtocol (f [] ...))

This is nicely documented in ClojureScript's extend-type docstring:

default, meaning the definitions will apply for any value,
unless an extend-type exists for one of the more specific
cases below.

nil, meaning the definitions will apply for the nil value.

It may worthwhile to document how one can provide default implementations for protocols in clojure as well, by using extend-type for Object & nil, on extend-type clj docstring. On the website is documented already.

CLI/deps reference use of :aliases is confusing in a couple of places

Tue, 08 Dec 2020 06:20:56 +0000

In almost all places where the CLI/deps reference uses :aliases it means the literal key :aliases in the deps.edn file.

In two places -- -X[:aliases] and -M[:aliases] -- it means instead a list of aliases.

I think removing the : in those two cases would be more consistent with the other uses of the word "aliases" in the text (as opposed to the _keyword :aliases).

Is it legal to apply keys / vals to a sequence of map entries?

Sun, 22 Nov 2020 18:08:57 +0000

The docstrings for keys and vals indicate these functions can be applied to maps. But, these functions also evidently work on sequences of map entries.

For example, this works:

(keys (filter (comp odd? val) {:a 1 :b 2 :c 3}))

Is the above program valid? Are keys and vals guaranteed to work on sequences of map entries?

doc string for reify is missing a statement of what it does

Mon, 16 Nov 2020 06:50:30 +0000

While the doc string for the function reify is quite detailed, it never seems to say what it does. The addition of a single sentence near the beginning of the doc string, perhaps one similar to the following, would help:

"reify defines an anonymous type, and creates and returns an instance of that type."

Note: The reference documentation for reify on clojure.org is better in this regard https://clojure.org/reference/datatypes#_reify and I copied then edited one of the sentences there to create the one proposed above.

Clojure Generation PDF blockchain

Mon, 27 Jul 2020 23:41:31 +0000

Hi guys, I'm going to start developing a project and I want you to recommend some technologies that I can use and be useful for my project.

Currently I have a system that generates PDF documents, but these documents do not have any type of security, what I want is: Generate PDF documents using blockchain and create a transactional query application for the generated documents

Can someone make a recommendation to start my project?

Thank you.!

What is the big O for clojure operations?

Wed, 15 Jul 2020 18:49:21 +0000

Hi, I'm new to clojure.

I have seen that there are some big O on the data structures part. But, is there a place on documentation showing all the big O of the operations in clojure?

Thanks!

How to see related functions in cider doc?

Tue, 14 Apr 2020 04:19:35 +0000

When using Cider, C-c C-d C-d shows the doc for a given functions. There should be a "See also" section at the bottom of the doc, listing related functions(e.g. "doseq" refers to "for"). However it's gone somehow. Did I accidentally turned it off or something? How do I get it back?

And by the way, where did that "related functions" information come from? It's not written in the doc string...

Should (doc get) 'format/example' refer to the 'associative' abstraction rather than a 'map'?

Fri, 20 Dec 2019 15:20:12 +0000

(doc get) returns
"-------------------------
clojure.core/get
([map key] [map key not-found])
Returns the value mapped to key, not-found or nil if key not present."

As 'get' works for a vector, as well as a map, I think the function addresses the associative abstraction, so this format would be less misleading:

([associative key] [associative key not-found])

Thanks to the experts at ClojureVerse who confirmed that my confusion at the example was justified and suggested I report it here.

Make clojure.core/get docstring more like clojure.core/get-in?

Wed, 27 Nov 2019 14:41:18 +0000

The docstring for get is:

Returns the value mapped to key, not-found or nil if key not present.

Multiple people at my work have found that sentence confusingly terse and hard to parse.

The docstring for get-in is:

Returns the value in a nested associative structure, where ks is a sequence of keys. Returns nil if the key is not present, or the not-found value if supplied.

Could the docstring for get be changed to:

Returns the value mapped to key. Returns nil if the key is not present, or the not-found value if supplied.

Logged and patch attached at: https://clojure.atlassian.net/browse/CLJ-2544

Migration from Closure to Python 3

Wed, 13 Nov 2019 04:15:39 +0000

Hello,

I would like to see if it is possible to migrate Closure code to Python.
Is-it possible? Do we have some scripts available to help for this?

I'm Python coder but don't have any expertise within Closure.

Can you help me?
Thanks in advance for your answers

Best regards,
Raoul

Doc strings for spit and clojure.java.io/writer mention but do not explain opts

Mon, 01 Apr 2019 19:42:55 +0000

I was trying to point my users at the reference documentation for spit to help them understand how they could customize output, and found that the options like :append true are not documented. Even if they are resourceful enough to figure out how to get to the docstring for clojure.java.io/writer itself, the options are not documented there either. I would basically need to teach them how to open a repl to explore the source code, or find it on GitHub, in order to figure this stuff out. Since they are generally not software developers, but musicians or their lighting/visuals staff trying to use a tiny bit of Clojure code to glue together shows, it would be nice if this information was easier to surface.

Some of this information can be found by scrolling down into examples on clojuredocs.org, but it would seem nice to have a definitive list of the options supported in the doc strings themselves.

Patch: clj-2500.patch