Interesting! Perhaps a Rationale section would help, explaining how it compares to alternatives (I see that hinted in Features, but still... ^^)

I was looking for something of this sort, although now I know scope-capture also existed

postmortem seems more full featured though

and also seems to have a bit more focus on working with cljs

the instrumentation bit also looks right like what I really wanted

@U45T93RA6 Hi, thanks! Yeah, I admit the current document is still hard to grasp what the library does really aim at, so I’ll try to improve it sometime soon. @UJVKWJTGE Thank you for the feedback! I hope it’ll be useful for your use case.

@U0508956F Hello, scope-capture's author here (thanks for mentioning it, I'm glad it gave you some inspiration!) I don't see much overlap between both libraries. scope-capture is above all about recreating the context of your code and projecting your REPL into it, and really not much about dealing with saved values. As such, Postmortem seems more akin to tracing debuggers, like tools.trace or Sayid (which is also very feature complete!). @UJVKWJTGE: FYI scope-capture does work with ClojureScript.

Might want to add Postmortem to the Clojure Toolbox! https://www.clojure-toolbox.com/

Also, I think not everyone knows about this, but there's a section about debugging in the REPL guide on http://clojure.org, it might be useful as an overview of the available options: https://clojure.org/guides/repl/enhancing_your_repl_workflow#debugging-tools-and-techniques

@U06GS6P1N Hi, thanks for your suggestions! Yes, I know the Clojure Toolbox, but I thought for no reason that it’s not actively maintained anymore. I will file a PR for Postmortem later 😉

> I don’t see much overlap between both libraries. scope-capture is above all about recreating the context of your code and projecting your REPL into it, and really not much about dealing with saved values. Once you save a local context as data, you can freely use that data later. Evaluating an expression in a reproduced context is one of the use cases for the saved data. Although Postmortem does not provide dedicated APIs for that, it could be done with relatively small effort using the existing APIs for most simple cases. For example, the last expression in the following code effectively works like scope-capture’s letsc:

(require '[postmortem.core :as pm])

(defn sum [n]
  (loop [n n sum 0]
    (pm/dump :sum)
    (if (= n 0)
      sum
      (recur (dec n) (+ sum n)))))

(sum 10) ;=> 55

;; This evaluates (+ sum n) with the local context of the 7th iteration
(let [{:keys [sum n]} (-> (pm/log-for :sum) (nth 7))]
  (+ sum n))

didn't know about that section, but unfortunately tools.trace doesn't seem to support cljs and that's one of the most useful ones I feel 😞

in fact, in clojure-toolsbox I see that scope-capture is the only debugging tool marked as cljs even

@U0508956F some would argue that for the most simple cases, you don't need a lib at all, you can just use the inline-def trick

https://clojurians.slack.com/archives/C06MAR553/p1576237425427800?thread_ts=1575899422.378000&cid=C06MAR553 That's far from the truth though, with dirac and all

I meant the "Debugging" section though

dirac is listed in "ClojureScript Development" it seems