Clojure Q&A - Recent questions and answers in REPL

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

Tue, 23 Dec 2025 08:15:40 +0000

Updating the version of rlwrap by building it from source fixed the issue.

The version installed on my FreeBSD system was 0.45, the latest version available for the package manager, building from source yielded version 0.48, which seems to have fixed the display bug :)

`(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.

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

Wed, 19 Feb 2025 21:30:58 +0000

Logged as https://clojure.atlassian.net/browse/CLJ-2897 - thanks!

Answered: add-lib behavior with REPL started via -e

Fri, 13 Dec 2024 18:22:17 +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.

Answered: prepl could have IDs for requests/responses

Sun, 02 Jun 2024 18:53:25 +0000

Output and error are streams and not tied to any particular request - there is no general way to correlate these, so no that does not seem like a good idea.

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

Sat, 16 Mar 2024 22:10:10 +0000

You don't need eval for this (which also isn't insecure in your context since you control all that's actually being evaled):

(let [data (vec (range 10))]
  (dotimes [idx (count data)]
    (intern *ns* (symbol (str "x" idx)) (nth data idx))))

=> x5
5

But, instead of doing things like this, I would strongly suggest tap>ing that data and using tools like Portal, Reveal, REBL. Incomparably more convenient than browsing complex nested data in a plain text REPL.

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

Tue, 27 Feb 2024 17:36:45 +0000

Seems like this may be same issue as https://ask.clojure.org/index.php/10735/prepl-warnings-remain-buffered-until-explicit-flushing-client ?

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.

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

Mon, 03 Jul 2023 13:50:56 +0000

Created https://clojure.atlassian.net/browse/CLJ-2788

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

Tue, 30 May 2023 16:44:56 +0000

This is covered in https://clojure.atlassian.net/browse/CLJ-2769 and will be fixed in the next alpha.

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

Mon, 27 Feb 2023 01:22:28 +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.

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

Fri, 23 Dec 2022 14:48:31 +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.

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

Tue, 01 Nov 2022 14:16:34 +0000

RT is an internal implementation class.

The Java API for Clojure is https://clojure.github.io/clojure/javadoc/clojure/java/api/package-summary.html.

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

Thu, 08 Sep 2022 12:07:18 +0000

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

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

Tue, 26 Apr 2022 20:14:39 +0000

Here is a patch. I don't have another way to contribute this.

From 52fe3111bf0f8f769121bdc2c383a3f11aac695f Mon Sep 17 00:00:00 2001
From: Ray McDermott <ray.mcdermott@opengrail.com>
Date: Tue, 26 Apr 2022 21:52:21 +0200
Subject: [PATCH] Fix for #CLJ-2645

---
 src/clj/clojure/core/server.clj |  4 ++--
 src/clj/clojure/core_print.clj  | 41 ++++++++++++++++++---------------
 2 files changed, 24 insertions(+), 21 deletions(-)

diff --git a/src/clj/clojure/core/server.clj b/src/clj/clojure/core/server.clj
index 3cda4d1f74..c774cab3b5 100644
--- a/src/clj/clojure/core/server.clj
+++ b/src/clj/clojure/core/server.clj
@@ -220,8 +220,8 @@
     (m/with-bindings
       (in-ns 'user)
       (binding [*in* (or stdin in-reader)
-                *out* (PrintWriter-on #(out-fn {:tag :out :val %1}) nil)
-                *err* (PrintWriter-on #(out-fn {:tag :err :val %1}) nil)]
+                *out* (PrintWriter-on #(out-fn {:tag :out :val %1}) nil true)
+                *err* (PrintWriter-on #(out-fn {:tag :err :val %1}) nil true)]
         (try
           (add-tap tapfn)
           (loop []
diff --git a/src/clj/clojure/core_print.clj b/src/clj/clojure/core_print.clj
index 18c5101c1d..4f10b780a1 100644
--- a/src/clj/clojure/core_print.clj
+++ b/src/clj/clojure/core_print.clj
@@ -559,23 +559,26 @@
 (defn ^java.io.PrintWriter PrintWriter-on
   "implements java.io.PrintWriter given flush-fn, which will be called
   when .flush() is called, with a string built up since the last call to .flush().
-  if not nil, close-fn will be called with no arguments when .close is called"
+  if not nil, close-fn will be called with no arguments when .close is called.
+  autoflush? determines if the PrintWriter will autoflush, false by default."
   {:added "1.10"}
-  [flush-fn close-fn]
-  (let [sb (StringBuilder.)]
-    (-> (proxy [Writer] []
-          (flush []
-                 (when (pos? (.length sb))
-                   (flush-fn (.toString sb)))
-                 (.setLength sb 0))
-          (close []
-                 (.flush ^Writer this)
-                 (when close-fn (close-fn))
-                 nil)
-          (write [str-cbuf off len]
-                 (when (pos? len)
-                   (if (instance? String str-cbuf)
-                     (.append sb ^String str-cbuf ^int off ^int len)
-                     (.append sb ^chars str-cbuf ^int off ^int len)))))
-        java.io.BufferedWriter.
-        java.io.PrintWriter.)))
+  ([flush-fn close-fn]
+   (PrintWriter-on flush-fn close-fn false))
+  ([flush-fn close-fn autoflush?]
+   (let [sb (StringBuilder.)]
+     (-> (proxy [Writer] []
+           (flush []
+             (when (pos? (.length sb))
+               (flush-fn (.toString sb)))
+             (.setLength sb 0))
+           (close []
+             (.flush ^Writer this)
+             (when close-fn (close-fn))
+             nil)
+           (write [str-cbuf off len]
+             (when (pos? len)
+               (if (instance? String str-cbuf)
+                 (.append sb ^String str-cbuf ^int off ^int len)
+                 (.append sb ^chars str-cbuf ^int off ^int len)))))
+         java.io.BufferedWriter.
+         (java.io.PrintWriter. ^boolean autoflush?)))))

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

Tue, 26 Apr 2022 13:03:57 +0000

This shadowing warning mirrors the Clojure behavior no?

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

Mon, 14 Feb 2022 15:52:46 +0000

Hi I extended CIDER and clojure-mode to work well exactly in this manner. You're right that the eval functions you are looking at are trying to show their results in the source buffer which is useful in some situations but the repl offers a lot more.

There is a keybinding C-c C-j which points at the cider-insert-commands-map. Here you'll find

C-c C-j e : cider-insert-last-sexp-in-repl
C-c C-j d: cider-insert-defun-in-repl
C-c C-j r: cider-insert-region-in-repl
C-c C-j n: cider-insert-ns-form-in-repl

The important ones here are e and d for last form and top-level form. These will send the forms to the repl. But there are some config that need to be set.

By default, this workflow puts the forms in the repl and anticipates you to keep typing. But we want to not put focus there and send the form to the repl to evaluate. So we want to set two options:

(setq cider-switch-to-repl-on-insert nil)
(setq cider-invert-insert-eval-p t)

the first option says we don't want to put the focus in the repl, keep the point (emacs lingo for the cursor) where it currently is. The second option is how we tell CIDER that we don't want to keep typing and modify the form, just eval it.

there's only one thing left to do. When sending the top level form with C-c C-j d, by default, CIDER might send the whole top level form

(comment
  (map inc (range 3))
  )

But we want to modify what is considered a top level form and when in the comment form consider (map inc (range 3)) a top level form, not the whole comment form. This is remedied by

(setq clojure-toplevel-inside-comment-form t)

Now you can send the top level form from anywhere inside of the (map inc (range 3)) and it will send the top level form you mean rather than the whole comment form.

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

Thu, 27 Jan 2022 22:34:16 +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

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

Mon, 13 Dec 2021 04:14:49 +0000

For a given namespace, you can get the full path to the resource it will be (or was) loaded from.

user=> (clojure.java.io/resource "clojure/core.clj")
#object[java.net.URL 0x59221b97 "jar:file:/home/justin/.m2/repository/org/clojure/clojure/1.10.1/clojure-1.10.1.jar!/clojure/core.clj"]

This will include the version of the package in the jar name (or else reveal the file path from which the code would be loaded).

Answered: Did TDEPS-187 break add-libs?

Thu, 12 Aug 2021 15:17:05 +0000

I think I would rephrase to say TDEPS-187 revealed how add-libs use of calc-basis was already broken. :)

I just updated add-libs to correct that in 83a477b305839c697666401508c395cfed29506a - that should help.

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

Wed, 14 Jul 2021 23:07:24 +0000

Do you have a src folder in ~? If so, what it is in it? (I'm wondering if you have src/user.clj and something in that script is causing the crash)

Answered: `source` errors on a function

Wed, 26 May 2021 15:04:26 +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.

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

Mon, 17 May 2021 21:06:31 +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.

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

Thu, 08 Apr 2021 17:04:28 +0000

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

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

Allow reader conditionals in prepl

Mon, 10 Dec 2018 16:43:30 +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.

Port 65535 incorrectly excluded

Fri, 17 Aug 2018 01:05:26 +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

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"