Make sequence lazy, make educe seq use sequence

Author: angusiguess

pixie/stdlib.pxi

@@ -1907,7 +1907,7 @@ not enough elements were present."
 
    ISeqable
    (-seq [self]
-     (seq (reduce conj self))))
+     (sequence xform coll)))
 
 (defn eduction
   "Returns a reducible/iterable application of the transducers
@@ -2189,12 +2189,18 @@ For more information, see http://clojure.org/special_forms#binding-forms"}
    (filter (complement pred) coll)))
 
 (defn sequence
-  "Returns a lazy sequence of `data`, optionally transforming it using `xform`.
-   Given an `eduction`, produces a lazy sequence of it."
-  ([eduction]
-   (when (seq eduction) (lazy-seq (cons (first eduction) (sequence (rest eduction))))))
-  ([xform data]
-   (sequence (eduction xform data))))
+  "Returns a lazy sequence of `data`, optionally transforming it using `xform`"
+  ([coll]
+   (if (seq? coll) coll
+       (or (seq coll) ())))
+  ([xform coll]
+   (let [step (defn step [xform acc xs]
+                (if-let [s (seq xs)]
+                  (let [next-acc ((xform conj) acc (first s))]
+                    (if (= acc next-acc) (step xform next-acc (next s))
+                        (concat (drop (count acc) next-acc) (step xform next-acc (next s)))))
+                  nil))]
+     (lazy-seq (step xform [] coll)))))
 
 (defn distinct
   {:doc "Returns the distinct elements in the collection."

tests/pixie/test-sequence.pxi

@@ -595,7 +595,7 @@
                   (seq)))
   ;; expanding transducer with nils
   (t/assert= '(1 2 3 nil 4 5 6 nil)
-             (eduction cat [[1 2 3 nil] [4 5 6 nil]])))
+             (seq (eduction cat [[1 2 3 nil] [4 5 6 nil]]))))
 
 (t/deftest test-trace
   (try
@@ -767,3 +767,23 @@
   (t/assert= (reduce (fn [a v] (reduced "foo")) 0 (iterate inc 1)) "foo")
   (t/assert= (reduce (fn [a v] (if (< a 10) (+ a v) (reduced a))) 0 (iterate (partial + 2) 1)) 16))
 
+(t/deftest test-sequence-empty-sequences
+  (t/assert= '() (take 1 (sequence (map inc) '())))
+  (t/assert= '() (take 1 (sequence (map inc) [])))
+  (t/assert= '() (take 1 (sequence (map inc) #{})))
+  (t/assert= '() (take 1 (sequence (map inc) {}))))
+
+(t/deftest test-sequence-non-empty-sequences
+  (t/assert= '(1 3) (take 2 (sequence (comp
+                                       (filter even?)
+                                       (map inc)) (range 3))))
+  (t/assert= '(1) (take 1 (sequence (distinct) (repeat 4 1)))))
+
+(t/deftest test-sequence-early-terminating-sequences
+  (t/assert= '() (take 5 (sequence (filter (fn [x] false)) (repeat 8 8))))
+  (t/assert= '(1 2) (take 3 (sequence (map identity) [1 2])))
+  (t/assert= #{[:a 1] [:b 2]} (into #{} (take 3 (sequence (filter (fn [[k v]]
+                                                                    (keyword? k)) {:a 1
+                                                                                   :b 2
+                                                                                   "c" 3
+                                                                                   "d" 4}))))))