Debugging in Clojure? [closed]

Answer 1

Here's a nice macro for debugging complicated let forms:

(defmacro def+
  "def with binding (def+ [{:keys [a b d]} {:a 1 :b 2 :d 3}])"
  [bindings]
  (let [let-expr (macroexpand `(let ~bindings))
        vars (filter #(not (.contains (str %) "__"))
               (map first (partition 2 (second let-expr))))
        def-vars (map (fn [v] `(def ~v ~v)) vars)]
    (concat let-expr def-vars)))

...and an essay explaining its use.

Answer 2

Coming from Java and being familiar with Eclipse, I like what Counterclockwise (the Eclipse plugin for Clojure development) has to offer: http://doc.ccw-ide.org/documentation.html#_debug_clojure_code

Answer 3

For IntelliJ there's an excellent Clojure plugin called Cursive. Among other things, it provides a REPL which you can run in debug mode and step through your Clojure code just like you would for e.g. Java.

I would second Peter Westmacott's answer though in that in my experience just running pieces of my code in the REPL is most of the time a sufficient form of debugging.

Answer 4

As of 2016 you can use Debux, a simple debugging library for Clojure/Script that works in conjunction with your repl as well as your browser's console. You can sprinkle dbg (debug) or clog (console.log) macros in your code and easily observe results of individual functions, etc, printed to your REPL and/or console.

From the project's Readme:

Basic usage

This is a simple example. The macro dbg prints an original form and pretty-prints the evaluated value on the REPL window. Then it returns the value without interfering with the code execution.

If you wrap the code with dbg like this,

(* 2 (dbg (+ 10 20))) ; => 60

the following will be printed in the REPL window.

REPL output:

dbg: (+ 10 20) => 30

Nested dbg

The dbg macro can be nested.

(dbg (* 2 (dbg (+ 10 20)))) ; => 60

REPL output:

`dbg: (+ 10 20) => 30`  

dbg: (* 2 (dbg (+ 10 20))) => 60

Answer 5

I have a little debugging macro that I find very useful:

;;debugging parts of expressions
(defmacro dbg[x] `(let [x# ~x] (println "dbg:" '~x "=" x#) x#))

You can insert it wherever you want to watch what's going on and when:

;; Examples of dbg
(println (+ (* 2 3) (dbg (* 8 9))))
(println (dbg (println "yo")))
(defn factorial[n] (if (= n 0) 1 (* n (dbg (factorial (dec n))))))
(factorial 8)

(def integers (iterate inc 0))
(def squares  (map #(dbg(* % %))   integers))
(def cubes    (map #(dbg(* %1 %2)) integers squares))
(take 5 cubes)
(take 5 cubes)

Answer 6

Use spyscope which implement a custom reader macro so that your debug code is also production code https://github.com/dgrnbrg/spyscope