如何在本地repl中查看Clojure局部变量？

Question

I want to play around and develop expressions based on local variables by placing a repl (with clojure.main/repl) inside a function body:

(ns something)

(defn myfunc [ p ]
   (let [local (+ p 10)]
        (clojure.main/repl)
        (+ local 100)))

(myfunc 666)

When I executed this, the repl starts ok, but the parameters of the function and local let-bindings do not seem to be visible in the prompt:

something=> p
CompilerException java.lang.RuntimeException: Unable to resolve symbol: p in this context
something=> local
CompilerException java.lang.RuntimeException: Unable to resolve symbol: local in this context

I have been able to pass the values by creating new ^:dynamic vars and setting their values locally with binding, but this is quite complex and requires separate binding for each local variable:

(def ^:dynamic x)

(defn myfunc [ p ]
   (let [local (+ p 10)]
        (binding [x local]
                 (clojure.main/repl))
        (+ local 100)))

Is there simpler way to pass/access local values in such local repl? Or is there some better way to do access the local variables from non-local repl, such as the "lein repl"?

Answer 1

Using the :init hook, you can define arbitrary vars in the REPL namespace.

(defn myfunc [p]
  (let [local (+ p 10)]
    (clojure.main/repl :init #(do (def p p) (def local local)))
    (+ local 100)))

Here's a repl macro to make adding a breakpoint easier:

(defmacro locals []
  (into {}
        (map (juxt name identity))
        (keys &env)))

(defn defs [vars]
  (doseq [[k v] vars]
    (eval (list 'def (symbol k) (list 'quote v)))))

(defmacro repl []
  `(let [ls# (locals)]
     (clojure.main/repl :init #(defs ls#))))

Now you can just drop in (repl) :

(defn myfunc [p]
  (let [local (+ p 10)]
    (repl)
    (+ local 100)))

Answer 2

I don't know a good answer for using the repl, but I favor using good old-fashioned printouts. This is facilitated by the spyx , let-spy , and let-spy-pretty macros:

(ns tst.demo.core
  (:use demo.core tupelo.core tupelo.test))

(defn myfunc [ p ]
  (spyx p)
  (let-spy [local (+ p 10)]
    (+ local 100)))

(dotest
  (spyx (myfunc 666)))

with result:

p              => 666
local          => 676
(myfunc 666)   => 776

Documentation on spyx & friends is here in the README , and there is also full API documentation on GitHub pages .