Hah, that’s a surprise. Perhaps, I don’t really remember what I was thinking bad then. 🙂

When I cider-jack-in outside of project, it success.

I guess this is because clj-refactor Maybe.

when you cider-jack-in you don’t need anything cider or clj-refactor related in your ~/.lein/profiles.clj

What must I do to get #break to work? If I place a #break and eval with cider-eval-defun-at-point it doesn't break when I call the function.

(defn testfn [] #break (+ 1 2)) then (testfn)

Now all of a sudden it works. I swear it didn't work before. 😛

oh well. as long as its working now 🙂

@dpsutton quickly and untested thoroughly:

(defun cider--eval-bindings (bindings)
  "Sends a (def bound-name expr) form to the cider repl for each
binding in bindings."
  (let ((bound-name (pop bindings))
        (init-expr (pop bindings)))
    (when bound-name
      (let ((form (concat "(def " bound-name " " init-expr ")")))
        (set-buffer (cider--get-repl-buffer))
        (insert form)
        (cider-repl-return)
        (cider--eval-bindings bindings)))))

(defun cider-eval-all-let-bindings ()
  (interactive)
  (when (cider--get-repl-buffer)
    (cider--eval-bindings (clojure--read-let-bindings))))

looks cool. just off hand, maybe remember the variable names and make an easy way to unintern them?

what does (clojure--read-let-bindings) look like?

if it's similar to what i did, i just grab that local environment which might be unbounded. not sure what we might clobber

also, with throwing your own defs in there, this is something to watch out for:

whatever> (def a 'bob)
#'whatever/a
whatever> a
bob
whatever> (defn a [x] (inc x))
#'whatever/a
whatever> a
#function[whatever/a]

Yes my version assumes so many things, good points up above for sure

Anothnr function would unbind all

i like it

although i might like a defnversion more

i think that's why i like the idea of killing it so you can enter it wherever you like

but make a (defn investigate-cider-env [] (let [bindings ....] body))

Btw the read function is in clojure-mode

cider-invnstigate-bindings maybe?

Or cider-repl-def-bindings

oh ok. this doesn't seem to be what i was thinking

my version was run during the debugging session and would capture the local variables during debugging

this included forms from function parameters and let bindings

this clojure mode style seems to try to parse things?

(<-- 
  code  "#dbg
(defn func [x y z]
  (let [a 1
        b 2]
    (let [c..."
  column  0
  coor  (3 2 2)
  debug-value  "16"
  file  "c:/Projects/pomegranate/src/main/clojure/cemerick/whatever.c..."
  id  "6"
  input-type  (dict ...)
  key  "d0e9418e-65ac-41ad-9263-2c3e2aa8e681"
  line  4
  locals  (("x" "1")
 ("y" "2")
 ("z" "3")
 ("a" "1")
 ("b" "2")
 ("c" "3")
 ("d" "4"))
  original-id  "74"
  prompt  nil
  session  "81f41c44-4cdd-4cd3-a027-5ccaeb53e6cc"
  status  ("need-debug-input")
)

(defn func [x y z]
  (let [a 1
        b 2]
    (let [c 3
          d 4]
      (+ a b c d x y z))))

so we just ask the debugger for the local values

Yes it looks at the code and sends def in the repl...Maybe a different feature

Because sometimes you want to use the value of something in a let

so it is useful for values known at compile time?

the benefit that i'm thinking of is you would captuze x y z and get those values and then you could investigate the form. since a, b, c, d are bound in the let you could just copy that over

No no, say I have a function, I know the value of the params, I have a let and i want to evaluate against those let bindings at runtime

So the the body of the let can be tweaked/debugged

ah ok. i think i see now