Simplified implementation of Batched deques

src/okasaki/batched_deque.clj

@@ -1,5 +1,5 @@
 (ns okasaki.batched-deque
-    (:refer-clojure :exclude [cons empty? last])
+    (:refer-clojure :exclude [cons empty? last split-at])
     (:use datatype.core
           okasaki.list))
 
@@ -16,24 +16,23 @@
     [[Quad 0 Nil 0 Nil]] true
     :else                false)
 
-(defun equalize
-    [queue]
-    [[Quad c1 [Cons h1 t1] c2 [Cons h2 t2]]] (let [diff (- c1 c2)]
-                                                 (cond (< diff -1) (recur (->Quad (inc c1) (->Cons h2 (->Cons h1 t1)) (dec c2) t2))
-                                                       (> diff +1) (recur (->Quad (dec c1) t1 (inc c2) (->Cons h1 (->Cons h2 t2))))
-                                                       :else       queue)))
-
 (defun checkf
     [queue]
-    [[Quad 0 Nil 1 _]] queue
-    [[Quad 1 _ 0 Nil]] queue
-    [[Quad 0 Nil c [Cons h t]]] (caseof
-                                 [(equalize (->Quad 1 (->Cons h Nil) (dec c) t))]
-                                 [[Quad cf f cr r]] (->Quad cr (rev r) cf (rev f)))
-    [[Quad c [Cons h t] 0 Nil]] (caseof
-                                 [(equalize (->Quad (dec c) t 1 (->Cons h Nil)))]
-                                 [[Quad cf f cr r]] (->Quad cr (rev r) cf (rev f)))
-    :else                       queue)
+    [[Quad 0 Nil cr r]] (if (> cr 1)
+                            (let [nnr (quot cr 2)
+                                  nnf (- cr nnr)
+                                  [nr rnf] (split-at nnr r)
+                                  nf (rev rnf)]
+                                (->Quad nnf nf nnr nr))
+                            queue)
+    [[Quad cf f 0 Nil]] (if (> cf 1)
+                            (let [nnf (quot cf 2)
+                                  nnr (- cf nnf)
+                                  [nf rnr] (split-at nnf f)
+                                  nr (rev rnr)]
+                                (->Quad nnf nf nnr nr))
+                            queue)
+    :else queue)
 
 (defun cons
     [elem deque]

src/okasaki/batched_queue.clj

@@ -1,5 +1,5 @@
 (ns okasaki.batched-queue
-    (:refer-clojure :exclude [empty?])
+    (:refer-clojure :exclude [empty? split-at])
     (:use datatype.core
           okasaki.list))
 

src/okasaki/binomial_heap.clj

@@ -1,5 +1,5 @@
 (ns okasaki.binomial-heap
-    (:refer-clojure :exclude [merge])
+    (:refer-clojure :exclude [merge split-at])
     (:use datatype.core
           okasaki.list))
 

src/okasaki/list.clj

@@ -1,4 +1,5 @@
 (ns okasaki.list
+    (:refer-clojure :exclude [split-at])
     (:use datatype.core))
 
 (defdatatype
@@ -12,4 +13,11 @@
 
 (defun rev [ts]
     [Nil] Nil
-    [[Cons t ts_]] (append (rev ts_) (->Cons t Nil)))
+    [[Cons t ts_]] (append (rev ts_) (->Cons t Nil)))
+
+(defun split-at
+    [num list]
+    [0 l] [Nil l]
+    [_ Nil] [Nil Nil]
+    [n [Cons h t]] (let [[f r] (split-at (dec n) t)]
+                       [(->Cons h f) r]))

test/okasaki/batched_deque_tests.clj

@@ -1,5 +1,5 @@
 (ns okasaki.batched-deque-tests
-    (:refer-clojure :exclude [cons empty? last])
+    (:refer-clojure :exclude [cons empty? last split-at])
     (:use okasaki.batched-deque
           okasaki.list
           clojure.test))

test/okasaki/binomial_heap_tests.clj

@@ -1,5 +1,5 @@
 (ns okasaki.binomial-heap-tests
-    (:refer-clojure :exclude [merge])
+    (:refer-clojure :exclude [merge split-at])
     (:use okasaki.list
           okasaki.binomial-heap
           clojure.test))

test/okasaki/list_tests.clj

@@ -1,4 +1,5 @@
 (ns okasaki.list-tests
+    (:refer-clojure :exclude [split-at])
     (:use okasaki.list
           clojure.test))