         (recur (z/up zip) child)
         build))))
 
-(defn node
-  [[triple & xs] element]
-  (if (= (count xs) 0)
-    (Node. triple element 0 [])
-    (Node. triple nil 1 [(node xs element)])))
+(defn fetch [node index]
+  "takes a node and an index and returns a recreation of the node at that index
+  as a limb"
+  (-> node
+      (crawl-to index)
+      (crawl-out)))
+

  this)

(defn left-to-right
  [position tree]
  (loop [pos position, branch (-> tree node-zip z/down), acc 0]
    (let [{:keys [sub-counter element]} (z/node branch)
          acc* (if element (inc acc) acc)]
      (if (= pos 0)

          nil
          (recur (z/next zip) (if elem (dec to-go) to-go)))))))

(defn crawl-out
  "this crawls up making from child node in a zipper making a replica of the
  nodes it sees"
  [child]
  (loop [zip child
         build nil]
    (let [{:keys [triple element]} (z/node zip)
          child (if build
