A library for interactive exploration of Clojure data.
Sometimes you have a gnarly piece of data and want to explore it. This can be done at the REPL, but navigation and exploration of the tree end up looking like this.
user> my-data
(let [x (rand-int 6) y (rand-int 10)] (if (< x y) x (+ y x)))
user> (nth *1 1)
[x (rand-int 6) y (rand-int 10)]
user> (class *1)
clojure.lang.PersistentVector
user> (nth *2 2)
y
user> (class *1)
clojure.lang.Symbol
That's far from ideal. In many cases, you want a more idiomatic way of walking a data structure-- without leaving the REPL. That's what Mangosteen, an interactive wrapper around clojure.zip, is for.
Use the function explore to navigate your data structure, like so.
user=> (use 'mangosteen.core)
nil
user=> (def my-data '(defn f [x] (if (= (mod x 2) 0) (quot x 2) (+ (* x 3) 1))))
#'user/my-data
user=> (explore my-data)
---------------------------------------------------------------------------
CURRENT FORM:
(defn f [x] (if (= (mod x 2) 0) (quot x 2) (+ (* x 3) 1)))
... of class clojure.lang.PersistentList
0: defn
1: f
2: [x]
3: (if (= (mod x 2) 0) (quot x 2) (+ (* x 3) 1))
(s)elect, (q)uit, (u)p to parent, or (0, 1, ...) to descend.
Your choice? 3
---------------------------------------------------------------------------
CURRENT FORM:
(if (= (mod x 2) 0) (quot x 2) (+ (* x 3) 1))
... of class clojure.lang.PersistentList
... parent is: (defn f [x] (if (= (mod x 2) 0) (quot x 2) (+ (* x 3) 1)))
0: if
1: (= (mod x 2) 0)
2: (quot x 2)
3: (+ (* x 3) 1)
(s)elect, (q)uit, (u)p to parent, or (0, 1, ...) to descend.
Your choice? 1
---------------------------------------------------------------------------
CURRENT FORM:
(= (mod x 2) 0)
... of class clojure.lang.PersistentList
... parent is: (if (= (mod x 2) 0) (quot x 2) (+ (* x 3) 1))
0: =
1: (mod x 2)
2: 0
(s)elect, (q)uit, (u)p to parent, or (0, 1, ...) to descend.
Your choice? s
[:select (= (mod x 2) 0)]
If (s)elect is used, the exploration terminates and the subform is
returned in [:select <subform>]. If (q)uit is used, then [:quit] is
returned.
Often it's desirable to "modify" a nested data structure. (I use quotes because the original is unchanged: a modified copy is returned.)
In modification, the function interact is used. (S)elect is used to
choose a node for modification, and (q)uit is used to stop making
edits. The modified copy of the data (with all edits) will be
returned.
user=> (def my-data [[1 2] [3 nil]])
#'user/my-data
user=> (interact my-data)
---------------------------------------------------------------------------
CURRENT FORM:
[[1 2] [3 nil]]
... of class clojure.lang.PersistentVector
0: [1 2]
1: [3 nil]
(s)elect, (q)uit, (u)p to parent, or (0, 1, ...) to descend.
Your choice? 1
---------------------------------------------------------------------------
CURRENT FORM:
[3 nil]
... of class clojure.lang.PersistentVector
... parent is: [[1 2] [3 nil]]
0: 3
1: nil
(s)elect, (q)uit, (u)p to parent, or (0, 1, ...) to descend.
Your choice? 1
---------------------------------------------------------------------------
CURRENT FORM:
nil
... of class nil
... parent is: [3 nil]
... is atomic
(s)elect, (q)uit, (u)p to parent, or (0, 1, ...) to descend.
Your choice? s
Edit to what? 4
---------------------------------------------------------------------------
CURRENT FORM:
4
... of class java.lang.Long
... parent is: [3 4]
... is atomic
(s)elect, (q)uit, (u)p to parent, or (0, 1, ...) to descend.
Your choice? q
[[1 2] [3 4]]
Copyright © 2014 Michael O. Church. Distributed under the MIT License.