     (make-finger-tree-deep
         (:monoid a)
         (:l a)
-        (app3 (force (:m a)) (apply nodes (:monoid a) (concat (:r a) (:l b))) (force (:m b)))
+        (force-early (delay (app3 (force (:m a)) (apply nodes (:monoid a) (concat (:r a) (:l b))) (force (:m b)))))
         (:r b)))
+
+(defmulti to-list (fn [tree] (class tree)))
+(defmethod to-list node-2 [{a :a b :b}] [a b])
+(defmethod to-list node-3 [{a :a b :b c :c}] [a b c])
+
+(defn split-digit [p i [a & as] ems cfn]
+    (if (nil? as)
+        [[] a []]
+        (let [ip (cfn i (ems a))]
+            (if (p ip)
+                [[] a as]
+                (let [[l x r] (split-digit p ip as ems cfn)]
+                    [(cons a l) x r])))))
 
 (defmulti split-tree (fn [tree p i] (class tree)))
 (defmethod split-tree finger-tree-single [{e :e m :monoid} _ _]

    (finger-tree-single. monoid e))
(defn make-finger-tree-deep [monoid l m r]
    (if (delay? m)
        (finger-tree-deep.
            monoid
            (delay (apply
                (:combine-fn monoid)
                (map
                    (fn [e] (extract-measure e monoid))
                    (concat
                        l
                        ((fn [v] (if (nil? v) [] [v])) (force m))
                        r))))
            l m r)
        (throw (IllegalArgumentException. "middle tree is not a delay"))))

; Reverse cons
(defn snoc [a lst] (concat lst [a]))
; Reverse rest
(defn tser [lst] (take (dec (count lst)) lst))

; Adds a new element to the front of the finger tree
(defmulti push-front (fn [tree value] (class tree)))

        1 [(make-node-3 monoid a b (first r))]
        2 [(make-node-2 monoid a b) (apply make-node-2 monoid r)]
        (cons (make-node-3 monoid a b (first r)) (apply nodes monoid (rest r)))))

(defn force-early [d] (do (force d) d))

(defmulti app3 (fn [l m r] [(class l) (class r)]))
(defmethod app3 [finger-tree-empty ::any] [l m r]
