Clojure Q&A - Recent activity in REPL

Closed: When using remote prepl server, repl is false, preventing use of add-lib and related functions

Tue, 21 Jul 2026 19:32:37 +0000

To reproduce:

clojure -J-Dclojure.server.jvm="{:port 5555 :accept clojure.core.server/io-prepl}"

Clojure 1.12.0
user=>

then

nc localhost 5555
*repl*
{:tag :ret, :val "false", :ns "user", :ms 0, :form "*repl*"}

Commented: Why does the REPL incorrectly display my command after I press enter?

Tue, 23 Dec 2025 20:29:58 +0000

I'm on Ubuntu 20.04 and 0.43 was the latest I could get through apt, so I used brew install rlwrap and that gave me 0.48 -- thank you for the build-from-source suggestion since that made me think of brew!

Commented: Add function that returns every interned keyword in the runtime

Fri, 12 Dec 2025 19:35:13 +0000

Just correct my comment above: since clojure.lang.Keyword.table isn't final, this issue isn't suspect to JEP 500. Still, having a public API to retrieve every interned keyword would be useful.

`(s/gen ...)` caches its failure to load generators and thus is incompatible with `add-lib`

Tue, 23 Sep 2025 16:23:58 +0000

Clojure 1.12.0
user=> (require '[clojure.spec.alpha :as s])
nil
user=> (s/def ::x #{1 2 3})
:user/x
user=> (s/gen ::x)
Execution error (FileNotFoundException) at user/eval145 (REPL:1).
Could not locate clojure/test/check/generators__init.class, clojure/test/check/generators.clj or clojure/test/check/generators.cljc on classpath.
user=> (add-lib 'org.clojure/test.check)
[org.clojure/test.check]
user=> (s/gen ::x)
Execution error (FileNotFoundException) at user/eval145 (REPL:1).
Could not locate clojure/test/check/generators__init.class, clojure/test/check/generators.clj or clojure/test/check/generators.cljc on classpath.

Answer selected: add-lib behavior with REPL started via -e

Fri, 13 Dec 2024 22:41:40 +0000

Definitely is classloader related. I assume the difference is that clojure.main/repl does:

(let [cl (.getContextClassLoader (Thread/currentThread))]
  (.setContextClassLoader (Thread/currentThread) (clojure.lang.DynamicClassLoader. cl)))

and clojure.main/eval-opt does not.

Seems like your code could do that too.

Closed: prepl warnings remain buffered until explicit flushing from the client

Sat, 15 Jun 2024 15:11:26 +0000

In a prepl session, Clojure warnings remain buffered and won't be sent to the client without flushing explicitly from the client side.

Here is an example prepl session using netcat (the lines starting with ;; indicate responses from the prepl server):

$ clojure -X clojure.core.server/start-server :name prepl :port 5555 :accept clojure.core.server/io-prepl :server-daemon false &
$ nc localhost 5555

(set! *warn-on-reflection* true)
;; {:tag :ret, :val "true", :ns "user", :ms 2, :form "(set! *warn-on-reflection* true)"}

(.toString (identity "foo"))
;; {:tag :ret, :val "\"foo\"", :ns "user", :ms 4, :form "(.toString (identity \"foo\"))"}
(binding [*out* *err*] (flush))
;; {:tag :err, :val "Reflection warning, NO_SOURCE_PATH:2:1 - reference to field toString can't be resolved.\n"}
;; {:tag :ret, :val "nil", :ns "user", :ms 4, :form "(binding [*out* *err*] (flush))"}

(defn identity [x] x)
;; {:tag :ret, :val "#'user/identity", :ns "user", :ms 3, :form "(defn identity [x] x)"}
(binding [*out* *err*] (flush))
;; {:tag :err, :val "WARNING: identity already refers to: #'clojure.core/identity in namespace: user, being replaced by: #'user/identity\n"}
;; {:tag :ret, :val "nil", :ns "user", :ms 2, :form "(binding [*out* *err*] (flush))"}

This seems to be caused by the fact that prepl's *err* PrintWriter is not autoFlush-enabled and that most of the Clojure warnings are not flushed explicitly.

Is this an issue to be addressed? Or is it an intended behavior and it's the client's responsibility to flush the error stream on a timely basis?

Commented: prepl could have IDs for requests/responses

Thu, 06 Jun 2024 06:46:24 +0000

It would technically be possible to create a new *out* binding for each eval that carries that id. For CLJ at least, for CLJS due to the async nature that wouldn't be of much benefit. I agree though that it seems best to me to treat out/err streams as separate from evaluation since they can come from to many "sources".

Closed: add-libs, etc in clojure 1.12 alphas causing "The filename or extension is too long" on windows

Wed, 05 Jun 2024 18:55:57 +0000

Using the new add-libs on Windows I seem to keep getting

CreateProcess error=206, The filename or extension is too long error.

This is possibly related to a similar issue caused by long classpath strings, but I'm getting this error when using add-libs, even when adding the same dependencies to my deps.edn and restarting my repl would not cause the error.

Original slack discussion that lead to this question:
https://clojurians.slack.com/archives/CFN4QDHPS/p1683207794496629

Commented: define several Vars at once in the REPL (convenience fn/macro)

Mon, 18 Mar 2024 15:40:27 +0000

`intern`, that's it! Thank you! Also, yeah solid advice regarding Portal/Reveal/REBL. Thanks again!

Commented: How to create a short-lived remote-prepl such that it can be gracefully shutdown?

Tue, 27 Feb 2024 19:28:47 +0000

I tried out the latest patch (with the Printwriter-On changes) as well as the `(binding [*out* *err*] (flush))` "hack solution" described in that thread. Unfortunately neither worked for me. It's probably related though. I will spend more time with it soon and report back.

Closed: add-libs fails when print-length is set in 1.12-alpha4

Thu, 08 Feb 2024 22:37:50 +0000

In version 1.12.0-alpha4, calling any of the clojure.repl.deps/add-libs related functions will fail when *print-length* is set, ostensibly to a number small enough to abbreviate your project's :deps when printing them.

So to reproduce, create a new project with 10 deps in deps.edn then

(set! *print-length* 5)
(add-libs '{my/lib {:mvn/version "0.1"}}) ;;fails

(set! *print-length* nil)
(add-libs '{my/lib {:mvn/version "0.1"}})  ;;now it works

I believe this is due to this line in clojure.tools.deps.interop

Answered: REPL not installed

Sun, 27 Aug 2023 15:40:20 +0000

You can try installing with https://github.com/casselc/clj-msi or https://github.com/borkdude/deps.clj and see if those work better for you.

Answer selected: Clojure repl won't show previous command with up arrow

Mon, 27 Feb 2023 08:14:36 +0000

clojure is the Clojure CLI tool. clj is a companion wrapper for it that adds rlwrap support for interactive editing, so try that instead.

Answered: help binding `clojure.test/test-out` in clojure.main/repl :init

Mon, 13 Feb 2023 15:29:57 +0000

Answer: a misunderstanding. clojure.main/repl uses (with-bindings (init) ...) but this is not clojure.core/with-bindings but clojure.main/with-bindings.

Answered: There's no way to enable warn-on-reflection from the command-line when running clojure.main

Wed, 08 Feb 2023 16:35:57 +0000

As a temporary workaround:

Putting

(alter-var-root #'*warn-on-reflection* (constantly true))

in user.clj also seems to work.

Answer selected: cant call function from clojure.core, dont know what's messed

Sun, 25 Dec 2022 23:33:16 +0000

If you are using Joyride, this isn't JVM Clojure.

Joyride is a ClojureScript environment to script VSCode which is using SCI to interpret the ClojureScript. Like ClojureScript it has no read-line function in the core library.

Comment edited: Could not locate clojure/core__init.class, clojure/core.clj or clojure/core.cljc on classpath

Sat, 12 Nov 2022 15:55:54 +0000

Thanks, it connected sucecessfully, There is a small modification:

public static IPersistentMap evalCodeMap() {
        Map<Object, Object> map = Maps.newHashMap();
        map.put(Clojure.read(":op"), Clojure.read("eval"));
        map.put(Clojure.read(":code"), Clojure.var("clojure.core", "eval").invoke("(+ 1 2)"));
        return PersistentHashMap.create(map);
    }

Clojure.var("nrepl.core", "message").invoke(client , evalCodeMap())

BTW, It seems that Clojure code is more simple.
it better to code with Clojure then call Clojure from Java? How to do that? gen-class or require namespace?

Commented: prepl only issues referral warnings once - is that right?

Tue, 26 Apr 2022 19:34:15 +0000

The method that reports that warning is `Namespace.warnOrFailOnReplace` and depending on how that method is called (via `intern` or `refer` or if nREPL uses it directly) and from where and which vars its checking it will report or not. Sadly, I don't know enough about nREPL to know how it might be calling that method.

Comment edited: Help writing a simple cider emacs defun to modify: cider-eval-last-sexp-to-repl

Mon, 14 Feb 2022 17:49:05 +0000

dpsutton - What a fast and brilliant answer! This adjusts Cider to my preferred work flow. The extra setting to keep the comment block from being the top-level form was something I hadn’t even expected to be able to fix. I’ve modified my config.el file and everything works exactly as I had hoped. Binding 'cider-insert-defun-in-repl (shown below) really optimizes my workflow.

Thanks again!

(define-key cider-mode-map (kbd "C-c RET") 'cider-insert-defun-in-repl)

Closed: io-prepl does not serialize exception thrown during serialization

Wed, 02 Feb 2022 21:51:22 +0000

io-prepl serializes eval results using valf but leaves exception as is if serialized value throws exceptions on print.

Repro:

# terminal 1
clj -X clojure.core.server/start-server \
  :name '"io-prepl"' \
  :port 7777 \
  :accept clojure.core.server/io-prepl \
  :server-daemon false

# terminal 2
nc localhost 7777
(reify Object (toString [_] (/ 1 0)))
{:tag :ret, :val {:via [{:type java.lang.ArithmeticException, :message "Divide by zero", :at [clojure.lang.Numbers divide "Numbers.java" 188]}], :trace [[clojure.lang.Numbers divide "Numbers.java" 188] [clojure.lang.Numbers divide "Numbers.java" 3901] [user$eval220$reify__221 toString "NO_SOURCE_FILE" 3] [clojure.core$str invokeStatic "core.clj" 555] [clojure.core$print_object invokeStatic "core_print.clj" 117] [clojure.core$fn__7297 invokeStatic "core_print.clj" 120] [clojure.core$fn__7297 invoke "core_print.clj" 120] [clojure.lang.MultiFn invoke "MultiFn.java" 234] [clojure.core$pr_on invokeStatic "core.clj" 3662] [clojure.core$pr invokeStatic "core.clj" 3665] [clojure.core$pr invoke "core.clj" 3665] [clojure.lang.AFn applyToHelper "AFn.java" 154] [clojure.lang.RestFn applyTo "RestFn.java" 132] [clojure.core$apply invokeStatic "core.clj" 667] [clojure.core$pr_str invokeStatic "core.clj" 4724] [clojure.core$pr_str doInvoke "core.clj" 4724] [clojure.lang.RestFn invoke "RestFn.java" 408] [clojure.core.server$io_prepl$fn__8978$fn__8979 invoke "server.clj" 289] [clojure.core.server$io_prepl$fn__8978 invoke "server.clj" 288] [clojure.core.server$prepl$fn__8964 invoke "server.clj" 239] [clojure.core.server$prepl invokeStatic "server.clj" 228] [clojure.core.server$prepl doInvoke "server.clj" 191] [clojure.lang.RestFn invoke "RestFn.java" 425] [clojure.core.server$io_prepl invokeStatic "server.clj" 283] [clojure.core.server$io_prepl doInvoke "server.clj" 272] [clojure.lang.RestFn invoke "RestFn.java" 397] [clojure.lang.AFn applyToHelper "AFn.java" 152] [clojure.lang.RestFn applyTo "RestFn.java" 132] [clojure.lang.Var applyTo "Var.java" 705] [clojure.core$apply invokeStatic "core.clj" 667] [clojure.core.server$accept_connection invokeStatic "server.clj" 73] [clojure.core.server$start_server$fn__8902$fn__8903$fn__8905 invoke "server.clj" 117] [clojure.lang.AFn run "AFn.java" 22] [java.lang.Thread run "Thread.java" 834]], :cause "Divide by zero", :phase :print-eval-result}, :ns "user", :ms 3, :form "(reify Object (toString [_] (/ 1 0)))", :exception true}

This causes problems for other prepls connected to io-prepl such as remote-prepl that always deserializes using its valf:

# terminal 3
clj
Clojure 1.10.3
user=> ((requiring-resolve 'clojure.core.server/remote-prepl) "localhost" 7777 *in* prn)
(reify Object (toString [_] (/ 1 0)))
{:tag :ret, :val {:via [{:type java.lang.ClassCastException, :message "class clojure.lang.PersistentArrayMap cannot be cast to class java.lang.String (clojure.lang.PersistentArrayMap is in unnamed module of loader 'app'; java.lang.String is in module java.base of loader 'bootstrap')", :at [clojure.core$read_string invokeStatic "core.clj" 3793]}], :trace [[clojure.core$read_string invokeStatic "core.clj" 3793] [clojure.core$read_string invoke "core.clj" 3793] [clojure.core.server$remote_prepl$fn__8992$fn__8994 invoke "server.clj" 322] [clojure.core.server$remote_prepl$fn__8992 invoke "server.clj" 321] [clojure.lang.AFn run "AFn.java" 22] [java.lang.Thread run "Thread.java" 834]], :cause "class clojure.lang.PersistentArrayMap cannot be cast to class java.lang.String (clojure.lang.PersistentArrayMap is in unnamed module of loader 'app'; java.lang.String is in module java.base of loader 'bootstrap')", :phase :read-eval-result}, :ns "user", :ms 1, :form "(reify Object (toString [_] (/ 1 0)))", :exception true}

In this case, the original exception (division by zero during printing) is shadowed by another exception (class cast exception by attempting to read-string a map)

Answer selected: clojure.core.server/io-prepl doesn't support read-line

Fri, 28 Jan 2022 05:57:27 +0000

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

Answered: clojure.main/report-error contains a call to pprint which may throw, obscuring the real failure

Tue, 18 Jan 2022 15:53:07 +0000

I moved your support issue into https://clojure.atlassian.net/browse/CLJ-2687

To have your patches considered, you'll need to sign the contributor agreement at https://clojure.org/dev/contributor_agreement

Commented: tools.deps - How do I list dependencies and their versions from the REPL?

Mon, 13 Dec 2021 04:17:47 +0000

I also use Alex's method shared in another answer, but sometimes this approach can reveal things that wouldn't be apparent otherwise, eg. a .clj or .class file that a library bundles accidentally / unexpectedly.

Closed: Port 65535 incorrectly excluded

Tue, 23 Nov 2021 21:04:00 +0000

The following code is used in {{src/clj/clojure/core/server.clj}} to validate whether a port number is valid:

(defn- validate-opts "Validate server config options" [{:keys [name port accept] :as opts}] (doseq [prop [:name :port :accept]] (required opts prop)) (when (or (not (integer? port)) (not (< -1 port 65535))) (throw (ex-info (str "Invalid socket server port: " port) opts))))

However this is very slightly incorrect, since port 65535 is excluded but it is actually a valid port.

`
user=> (defn is-invalid-port [port] (or (not (integer? port)) (not (< -1 port 65535))))

'user/is-invalid-port

user=> (is-invalid-port 65534)
false
user=> (is-invalid-port 65535) ; should be false!
true
user=> (is-invalid-port 65536)
true
`

This is corroborated by (link: https://docs.oracle.com/javase/7/docs/api/java/net/ServerSocket.html#ServerSocket(int) text: {{ServerSocket}}'s Javadoc):

{quote}
IllegalArgumentException - if the port parameter is outside the specified range of valid port values, which is between 0 and 65535, inclusive.
{quote}

Patch: port-65535-obo-v2.patch

Prescreened: Alex Miller

Commented: Did TDEPS-187 break add-libs?

Fri, 13 Aug 2021 07:36:07 +0000

Aha! Thanks :D

Commented: clj repl crashing when launched and pwd is ~, otherwise from any other directory it's fine

Thu, 15 Jul 2021 07:31:47 +0000

Something to bear in mind... Thanks a lot..

PS:- https://stackoverflow.com/questions/68374421/clj-repl-crashing-when-launched-and-pwd-is/68389626#68389626

Answer selected: `source` errors on a function

Wed, 26 May 2021 16:44:13 +0000

I think we may have this logged somewhere already, has to do with how source macro does not have the ns context to resolve auto-resolved keywords at read time, which is definitely fixable now that we have pluggable resolver in read.

Closed: Allow reader conditionals in prepl

Wed, 19 May 2021 19:44:23 +0000

The ClojureScript prepl implementation allows for reader conditionals, the Clojure one does not. Allowing reader conditionals in the Clojure prepl implementation will bring the two implementations in line with each other.

Answer selected: Should load-file use the repl's eval function?

Mon, 17 May 2021 21:07:11 +0000

The eval function of the current repl is for eval'ing things read by the repl, not all things eval'ed in the runtime. So, no this is not an expectation you should have.

Answered: Why does evaluating an eduction cause the reader to fail?

Tue, 11 May 2021 02:48:55 +0000

In general, not every object is eval-able. When eval'ing something like this, a class gets generated that's something like (fn* [] <eduction-object>). To create the class, that eduction object needs to get stored in the bytecode. In this case, the transducer function can't be directly stored in the bytecode - the Compiler in this case makes a hail mary and does a print-dup to a string like "#=(clojure.core$map$fn__596.)" Then that value is attempting to be read back during the eval but the class is not available with that constructor. That's the read error you're seeing.

It's the same kind of exception you often get when returning objects rather than forms from a macro and in fact you can replicate the error with macros too (this is a common macro error):

(defmacro foo [] (eduction (map identity) [#'+ 2 3]))
(foo)

I don't know that I would expect this to work - as you say, eductions are collections, but not seqs or lists.

Answered: What cool things do you do with `clojure.main/repl`?

Wed, 05 May 2021 11:57:30 +0000

Doesn't seem to be implemented on top of clojure.main/repl specifically, but Datawalk is a pretty cool example of what you can do with a sub-REPL.

Hide Warnings from Com.Google.Cloud.Translate

Tue, 26 Jan 2021 02:38:21 +0000

Howdy. I am using this excellent wrapper over google translate. https://github.com/billwinkler/google-translate

However, whenever I invoke
(gt/translate! ... :from "" :to "")
I get warnings printed to the console / REPL.
I would really like to not see these warnings:

WARNING: Ignoring Application Default Credentials GOOGLE_APPLICATION_CREDENTIALS: using explicit setting for API key instead.

I am relatively new to logging and understand the java side of things is a mess, is there any way I can prevent seeing these warnings in the REPL ?

Answered: Why have prompts on previous lines in the clj command-line REPL started disappearing?

Thu, 07 Jan 2021 15:21:20 +0000

This is because the clj command internally uses the rlwrap command to provide conventional REPL keyboard shortcuts.

rlwrap in turn uses the readline library, and the latest version of that (8.1) has exposed a bug in rlwrap, causing the disappearing prompt:

https://github.com/hanslub42/rlwrap/issues/108

Until a fixed release of the rlwrap command is available, this bug can be worked around by adding the following to an .inputrc file in your home directory (i.e. ~/.inputrc — create it if it doesn't already exist)

$if clojure
    set enable-bracketed-paste off
$endif

If exiting and restarting the clj command isn't enough for that new configuration to be picked up, try restarting your terminal too.

UPDATE: rlwrap version 0.44 has been released, making the workaround described above no longer needed. See here for which version of rlwrap is available in various package repositories.

Answered: Problem whilst requiring clojure clojure.data.csv :as csv

Tue, 05 Jan 2021 23:35:59 +0000

Asked and answered on StackOverflow: https://stackoverflow.com/questions/65543714/problems-while-creating-a-deps-edn-file (so folks can read some history of the issue and what has already been suggested).

Answered: database updates executed with lein repl, but not with lein run

Fri, 27 Nov 2020 15:33:27 +0000

map is lazy. You will probably get better results if you wrap the (map ...) call inside of a (doall (map ...)) call, or if you use mapv (which is eager) instead of map.

Note that in a REPL, the P (Print) part of REPL will force a lazy return value from map to be fully evaluated so that it can be printed.

Answered: Change in behavior of default javadoc `feeling-lucky-url` due to google change

Mon, 09 Nov 2020 15:59:29 +0000

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

Answered: REPL seems not to work

Sun, 08 Nov 2020 22:48:55 +0000

I'm not sure why you would see this - have never seen an issue like this in the past. If you are still having this issue, try Ctrl-\ to get a stack dump and attach the result here.

Answered: Can you specify the location .nrepl-port file is written to?

Fri, 09 Oct 2020 17:23:38 +0000

Not a nrepl expert, but with a search about "nrepl-port" in github.com/nrepl/nrepl i find this:
https://github.com/nrepl/nrepl/blob/933e08b7ef0a66002bf5bf6369088515e1c4b42f/src/clojure/nrepl/cmdline.clj#L420

how to require clojure libs as classes instead of clj file to reduce repl start up time during development?

Sat, 03 Oct 2020 07:32:25 +0000

Hi!

i read about reducing repl start up time during dev and tried to apply these knowledge to start REPL using Leiningen (in the article Alex shows this practice using deps.edn).

My steps:

I overrided clojure.core/load var to track time elapsed on loading module with:

(alter-var-root #'clojure.core/load (fn [origin-fn]
                                  (if (get (meta origin-fn) ::track-load?)
                                    origin-fn
                                    (vary-meta (fn [& args]
                                                 (let [start# (System/nanoTime)
                                                       ret# (apply origin-fn args)
                                                       elapsed-ms# (/ (double (- (System/nanoTime) start#)) 1000000.0)]
                                                   (newline)
                                                   (pr {:args (vec args)
                                                        :ms   elapsed-ms#})
                                                   (newline)
                                                   ret#))
                                               merge
                                               {::track-load? true}))))

I noticed that loading core clojure parts takes time ~0.10-0.20 ms and loading third party libs modules (cheshire for example) , takes ~200-400ms.

As i understand, main idea of reducing REPL start up time is the priority of compiled class before clj module if clj module was not changed. So we can compile third party libs and get benefit of not parsing their clj files but use their compiled classes.

I compiled all clojure files (my and libs) via leiningen uberjar and added folder with compiled class files to :checkout-deps-shares, i guess it is a way to add folder with class files to classpath:

:checkout-deps-shares [:source-paths :test-paths
                     ~(fn [p] (str (:root p) "/target/uberjar/classes/*"))]

Then i restarted repl, overrided clojure.core/load to track modules load time and as experiment do following:

(time (require 'runtime.account :reload-all))

where runtime.account is one of my root modules.

As a result i cannot see any difference in loading time of third party libs modules :/.

Maybe you can give me some details about mechanism deciding to load class file or clj file and some way to monitor that activity?

Thanks!

Lein repl error: As of 2.8.2, the repl task is incompatible with Clojure versions older than 1.7.0.

Fri, 11 Sep 2020 23:06:45 +0000

I am trying to work through an example in the Clojure Workshop. I created a folder and in that included the following project.clj file.

(defproject learncsv "1.0.0-SNAPSHOT"
 :dependencies [[org.clojure/data.csv "1.0.0"]
             [semantic-csv "0.2.1-alpha1"]])

Then, I went to the terminal and typed

lein repl

I got the following error:

OpenJDK 64-Bit Server VM warning: Options -Xverify:none and -noverify were deprecated 

in JDK 13 and will likely be removed in a future release.
As of 2.8.2, the repl task is incompatible with Clojure versions older than 1.7.0.
You can downgrade to 2.8.1 or use `lein trampoline run -m clojure.main` for a simpler 
 fallback repl.
Subprocess failed (exit code: 1)

I am super new to clojure. Never included any dependencies. Would really appreciate any help.

Edit: If I run lein repl in a folder that does not have any project.clj then it starts fine. And, it shows my clojure version as 1.10. So I am not sure why the error seems to suggest that I am using Clojure version older than 1.7.0

Thank you.

Cartesian Product of a Single linked list

Fri, 10 Apr 2020 23:35:11 +0000

Hello,

I have a task to write a function which prints a cartesian product of a single linked list.
This is what my lecturer gave us and it works perfectly,but I just don't understand how they work. More specifically I can't figure out (func (:data node)) this line. I know that it gives us data of the node but what is func doing?
The slist-cartesian function is totally confusing for me.
Please explain to me how they work.
Thank you!

(defn slist-iter [lst func]
(loop [node (deref (:head lst))]

(if (not (nil? node))
  (do
    (func (:data node))
    (recur (deref (:next node)))))))

(defn slist-cartesian [lst]
(slist-iter
lst
(fn [x]

 (slist-iter
  lst
  (fn [y]
    (println x y))))))

How should I decide whether to apply file/line metadata

Tue, 26 Nov 2019 09:59:27 +0000

It's quite difficult when writing REPL client tooling to know whether it's safe to attach the clojure.core/eval-file and clojure.core/line metadata to the forms being sent. You can make an approximation based on the start character, but it doesn't seem like a reliable approach to this problem.

An example of where the metadata fails is if you're sending a number or string to be evaluated.

remote-prepl blocks main-thread upon in-reader's eos

Fri, 10 May 2019 15:00:21 +0000

When the in-reader passed to {{clojure.core.server/remote-prepl}} reaches end-of-stream, an attempt is made to close the socket's reader. This however blocks the main-thread as (mostly) the socket is still being read from.

{code:none}
$ clj -J-Dclojure.server.jvm="{:port 5555 :accept clojure.core.server/io-prepl}" -r
Clojure 1.10.0
user=> (clojure.core.server/remote-prepl "127.0.0.1" 5555 *in* prn)
;; as expected:
1
{:tag :ret, :val 1, :ns "user", :ms 0, :form "1"}
^D ;; hangs - ^C required to exit process

What I would expect to happen in this case is that upon {{^D}} the initial repl re-appears (similar to how {{(clojure.core.server/io-prepl)}} behaves).

What does work:
{code:none}
$ clj -J-Dclojure.server.jvm="{:port 5555 :accept clojure.core.server/io-prepl}" -r
Clojure 1.10.0
user=> (clojure.core.server/remote-prepl "127.0.0.1" 5555 *in* prn)
:repl/quit
^D
nil
user=> _

Looking at the code though it seems that this is not the intented way to terminate the prepl.

Add switch for `clojure --version`

Wed, 08 May 2019 17:46:59 +0000

Clojure should support the `--version` and `-v` switches that are nearly universal among software tools.

Suggested output is EDN format:

{:version {:clojure "1.10.1-beta1" :java "Java 12"}}

Support fully qualified Symbol for clojure.main -m

Wed, 24 Jan 2018 15:56:09 +0000

Given the new tools.deps CLI capabilities it would be very convenient to have a {{clojure.main -m}} option that optionally allows calling specific function, not just {{-main}}.

;; calling main clojure -m some.util args ... ;; calling other fns clojure -m some.util/task args ... clojure -m some.util/another-task args ...

`
(ns some.util)

(defn -main [& args] ...)
(defn task [& args] ...)
(defn another-task [& args] ...)
`

Creating utilities for use with the {{clojure}} tool otherwise requires creating a new namespace for each "task" (or resorting to {{-e}} or {{script.clj}} files).

Leiningen supports the {{lein run -m some.util/task ...}} notation. shadow-cljs does as well.

Update `clj` REPL with hint: (use Ctrl-D to exit)

Mon, 11 Dec 2017 22:12:01 +0000

Update clojure.main REPL for the clj tool with a hint for terminating the session via Ctrl-D, like so (changes in bold):

~ > clj
Clojure 1.9.0 (use Ctrl-D to exit)
user=>
~ >

The lein repl accepts exit, quit, and Crtl-D to exit; the clj repl accepts only Crtl-D. A small hint upon startup on the proper way to terminate the repl session will smooth the experience for users expecting for their old habits to work.

Patch: clj-2286.patch

Allow runtime modification of REPL exception handling

Tue, 11 Oct 2016 16:20:45 +0000

Problem Statement

Clojure's REPL is capable of paramterizing almost every aspect of its functionality, including how uncaught exceptions are printed. In the current implementation, these customization hooks are passed in as arguments and closed over, meaning that they cannot be changed once the REPL is started.

Many development tools want to override how the REPL handles uncaught errors. Examples of useful customizations include (but are not limited to):

Formatted exception messages (including whitespace and ANSI coloring)
Alternative representations for certain types of exceptions (e.g, Spec errors)
Dropping into a graphical interaction mode to better inspect ex-data.

Currently, this type of customization must be applied before a REPL is started, meaning that changing how a REPL displays errors requires support from (or plugins to) a third-party tool such as Boot or Leiningen.

Alternatives

<BR/>
1. Take no action.

Third-party tool support is required to create customized exception handling in the REPL. Tools have different techniques for doing this:

nREPL can intercept the exception on the wire and passes it through middleware
Leiningen plugins alter the root binding of {{clojure.main/repl-caught}}.
Boot allows users to build a task to invoke {{clojure.main/repl}} with the desired arguments.

Users will continue to select one of these according to their tooling preferences.

Benefits:
1. No effort or changes to the existing code.

Tradeoffs:
1. Tools will continue to implement their own diverse, sometimes hacky techniques for printing custom exceptions.
2. Any library intended to provide alternative exception handling will be tied to a specific launcher tool.

Make the REPL exception handler dynamically rebindable

If the REPL exception handler were a dynamic, thread-local var, users and libraries could change the behavior of the currently running REPL.

Benefits:
1. Users and libraries can freely override how exceptions are printed, regardless of how Clojure was launched.
2. Fully backwards compatible with existing tools.

Tradeoffs:
1. It will be possible for library authors to provide "bad" or poorly reasoned error printers. This is still possible with launch tools, but the barrier of entry is even lower with libraries.

The attached patch implements this option.

Encourage users to start new REPLs instead

In many Clojure environments, it's possible to explicitly launch a REPL from within another REPL. This sub-REPL could have the desired :caught hook.

Benefits:
1. No effort or changes to the existing code.
2. "Functionally pure", and in alignment with the evident design of the current REPL.

Tradeoffs:
1. There is a non-trivial subset of Clojure developers who do not know exactly how REPLs work. They are likely to be confused or subject to increased cognitive load. Insofar as this set of beginner/intermediate developers are precisely who enhanced error messages are meant to help in the first place, this solution is counterproductive.
2. For better or for worse, many existing and widely used tools do not support this. This does not work at all in nREPL, for example. However, even the simplest command-line REPLs behavior would change for the worse; sending a EOF (accidentally or otherwise) would always kill the sub-REPL with no feedback as to what just happened.

New socket server startup proactively loads too much code, slowing boot time

Tue, 09 Feb 2016 13:11:33 +0000

In the new socket server code, clojure.core.server is proactively loaded (regardless of whether servers are in the config), which will also load clojure.edn and clojure.string.

Approach: Delay loading of this code until the first server config is found. This improves startup time when not using the socket server about 0.05 s.

Patch: clj-1891.patch

Expose clojure.repl/doc as a function call

Wed, 28 Oct 2015 18:29:20 +0000

Restructure the printing function {{clojure.repl/doc}} so that it calls a fuction {{clojure.repl/doc-fn}} for its data - in the same way as {{dir}} calls {{dir-fn}}. Make {{doc-fn}} public so that it can be called directly and allow developers to parse and display the data as needed.

Use case: I am making a namespace inspector (using JavaFX) (somewhat like the Swing-based tree-inspector in Clojure), and when getting a function, I would like to display the same meta-information as "doc" prints in the REPL - including the special forms data coded in a private var/map in Clojure.

Patch: doc-fn.patch

repl value of file is "NO_SOURCE_PATH", of source-path is "NO_SOURCE_FILE"

Tue, 19 Feb 2013 22:22:10 +0000

repl value of *file* is "NO_SOURCE_PATH", of *source-path* is "NO_SOURCE_FILE"