CLJS-836: Replace seq-based iterators with direct iterator for all non-seq collections that use SeqIterator

Iterators are now created for PesistentHashMap, PersistentHashSet, PersistentQueue, and
any type created by defrecord.

Author: spinningtopsofdoom

benchmark/cljs/benchmark_runner.cljs

@@ -322,6 +322,26 @@
 (simple-benchmark [r r] (last r) 1)
 (println)
 
+(println ";; iterators")
+(def ipmap (apply hash-map (range 2000)))
+
+(println ";; Sequence iterator")
+(simple-benchmark [s (seq ipmap)]
+                  (let [iter (seq-iter s)]
+                    (loop [v nil]
+                      (if (.hasNext iter)
+                        (recur (.next iter))
+                        v)))
+                  1000)
+(println ";; Direct iterator")
+(simple-benchmark []
+                  (let [iter (-iterator ipmap)]
+                    (loop [v nil]
+                      (if (.hasNext iter)
+                        (recur (.next iter))
+                        v)))
+                  1000)
+
 (println ";;; comprehensions")
 (simple-benchmark [xs (range 512)] (last (for [x xs y xs] (+ x y))) 1)
 (simple-benchmark [xs (vec (range 512))] (last (for [x xs y xs] (+ x y))) 4)

src/main/cljs/cljs/core.cljs

@@ -5330,6 +5330,21 @@ reduces them without incurring seq initialization"
 
 ;;; PersistentQueue ;;;
 
+(deftype PersistentQueueIter [^:mutable fseq riter]
+  Object
+  (hasNext [_]
+    (or (and (some? fseq) (seq fseq)) (and (some? riter) (.hasNext riter))))
+  (next [_]
+    (cond
+      (some? fseq)
+      (let [ret (first fseq)]
+        (set! fseq (next fseq))
+        ret)
+      (and (some? riter) ^boolean (.hasNext riter))
+      (.next riter)
+      :else (throw (js/Error. "No such element"))))
+  (remove [_] (js/Error. "Unsupported operation")))
+
 (deftype PersistentQueueSeq [meta front rear ^:mutable __hash]
   Object
   (toString [coll]
@@ -5380,6 +5395,10 @@ reduces them without incurring seq initialization"
   ICloneable
   (-clone [coll] (PersistentQueue. meta count front rear __hash))
 
+  IIterable
+  (-iterator [coll]
+    (PersistentQueueIter. front (-iterator rear)))
+
   IWithMeta
   (-with-meta [coll meta] (PersistentQueue. meta count front rear __hash))
 
@@ -5607,6 +5626,19 @@ reduces them without incurring seq initialization"
 
 (set! (.-fromObject ObjMap) (fn [ks obj] (ObjMap. nil ks obj 0 nil)))
 
+;; Record Iterator
+(deftype RecordIter [^:mutable i record base-count fields ext-map-iter]
+  Object
+  (hasNext [_]
+    (or (< i base-count) (.hasNext ext-map-iter)))
+  (next [_]
+    (if (< i base-count)
+      (let [k (nth fields i)]
+        (set! i (inc i))
+        [k (-lookup record k)])
+      (.next ext-map-iter)))
+  (remove [_] (js/Error. "Unsupported operation")))
+
 ;; EXPERIMENTAL: subject to change
 (deftype ES6EntriesIterator [^:mutable s]
   Object
@@ -6109,6 +6141,44 @@ reduces them without incurring seq initialization"
 
 (declare ArrayNode)
 
+ (deftype NodeIterator [arr ^:mutable i ^:mutable next-entry ^:mutable next-iter]
+  Object
+  (advance [this]
+    (let [len (alength arr)]
+      (loop []
+        (if (< i len)
+          (let [key (aget arr i)
+                node-or-val (aget arr (inc i))
+                ^boolean found
+                (cond (some? key)
+                      (set! next-entry [key node-or-val])
+                      (some? node-or-val)
+                      (let [new-iter (-iterator node-or-val)]
+                        (if ^boolean (.hasNext new-iter)
+                          (set! next-iter new-iter)
+                          false))
+                      :else false)]
+            (set! i (+ i 2))
+            (if found true (recur)))
+          false))))
+  (hasNext [this]
+    (or (some? next-entry) (some? next-iter) (.advance this)))
+  (next [this]
+    (cond
+      (some? next-entry)
+      (let [ret next-entry]
+        (set! next-entry nil)
+        ret)
+      (some? next-iter)
+      (let [ret (.next next-iter)]
+        (when-not ^boolean (.hasNext next-iter)
+          (set! next-iter nil))
+        ret)
+      ^boolean (.advance this)
+      (.next this)
+      :else (throw (js/Error. "No such element"))))
+  (remove [_] (js/Error. "Unsupported operation")))
+
 (deftype BitmapIndexedNode [edit ^:mutable bitmap ^:mutable arr]
   Object
   (inode-assoc [inode shift hash key val added-leaf?]
@@ -6303,7 +6373,11 @@ reduces them without incurring seq initialization"
                 :else inode)))))
 
   (kv-reduce [inode f init]
-    (inode-kv-reduce arr f init)))
+    (inode-kv-reduce arr f init))
+
+  IIterable
+  (-iterator [coll]
+    (NodeIterator. arr 0 nil nil)))
 
 (set! (.-EMPTY BitmapIndexedNode) (BitmapIndexedNode. nil 0 (make-array 0)))
 
@@ -6320,6 +6394,26 @@ reduces them without incurring seq initialization"
           (recur (inc i) j bitmap))
         (BitmapIndexedNode. edit bitmap new-arr)))))
 
+(deftype ArrayNodeIterator [arr ^:mutable i ^:mutable next-iter]
+  Object
+  (hasNext [this]
+    (let [len (alength arr)]
+      (loop []
+        (if-not (and  (some? next-iter) ^boolean (.hasNext next-iter))
+          (if (< i len)
+            (let [node (aget arr i)]
+              (set! i (inc i))
+              (when (some? node)
+                (set! next-iter (-iterator node)))
+              (recur))
+            false)
+          true))))
+  (next [this]
+    (if ^boolean (.hasNext this)
+      (.next next-iter)
+      (throw (js/Error. "No such element"))))
+  (remove [_] (js/Error. "Unsupported operation")))
+
 (deftype ArrayNode [edit ^:mutable cnt ^:mutable arr]
   Object
   (inode-assoc [inode shift hash key val added-leaf?]
@@ -6415,7 +6509,11 @@ reduces them without incurring seq initialization"
                   @init
                   (recur (inc i) init)))
               (recur (inc i) init)))
-          init)))))
+          init))))
+
+ IIterable
+ (-iterator [coll]
+    (ArrayNodeIterator. arr 0 nil)))
 
 (defn- hash-collision-node-find-index [arr cnt key]
   (let [lim (* 2 cnt)]
@@ -6522,7 +6620,11 @@ reduces them without incurring seq initialization"
                 editable))))))
 
   (kv-reduce [inode f init]
-    (inode-kv-reduce arr f init)))
+    (inode-kv-reduce arr f init))
+
+  IIterable
+  (-iterator [coll]
+    (NodeIterator. arr 0 nil nil)))
 
 (defn- create-node
   ([shift key1 val1 key2hash key2 val2]
@@ -6660,6 +6762,18 @@ reduces them without incurring seq initialization"
 
 (declare TransientHashMap)
 
+(deftype HashMapIter [nil-val root-iter ^:mutable seen]
+  Object
+  (hasNext [_]
+    (and ^boolean seen ^boolean (.hasNext root-iter)))
+  (next [_]
+    (if-not ^boolean seen
+      (do
+        (set! seen true)
+        nil-val)
+      (.next root-iter)))
+  (remove [_] (js/Error. "Unsupported operation")))
+
 (deftype PersistentHashMap [meta cnt root ^boolean has-nil? nil-val ^:mutable __hash]
   Object
   (toString [coll]
@@ -6685,6 +6799,13 @@ reduces them without incurring seq initialization"
   ICloneable
   (-clone [_] (PersistentHashMap. meta cnt root has-nil? nil-val __hash))
 
+  IIterable
+  (-iterator [coll]
+    (let [root-iter (if ^boolean root (-iterator root) nil-iter)]
+      (if has-nil?
+        (HashMapIter. nil-val root-iter false)
+        root-iter)))
+
   IWithMeta
   (-with-meta [coll meta] (PersistentHashMap. meta cnt root has-nil? nil-val __hash))
 
@@ -7812,6 +7933,16 @@ reduces them without incurring seq initialization"
 
 (declare TransientHashSet)
 
+(deftype HashSetIter [iter]
+  Object
+  (hasNext [_]
+    (.hasNext iter))
+  (next [_]
+    (if ^boolean (.hasNext iter)
+      (aget (.-tail (.next iter)) 0)
+      (throw (js/Error. "No such element"))))
+  (remove [_] (js/Error. "Unsupported operation")))
+
 (deftype PersistentHashSet [meta hash-map ^:mutable __hash]
   Object
   (toString [coll]
@@ -7835,6 +7966,10 @@ reduces them without incurring seq initialization"
   ICloneable
   (-clone [_] (PersistentHashSet. meta hash-map __hash))
 
+  IIterable
+  (-iterator [coll]
+    (HashSetIter. (-iterator hash-map)))
+
   IWithMeta
   (-with-meta [coll meta] (PersistentHashSet. meta hash-map __hash))
 

src/main/clojure/cljs/core.cljc

@@ -1634,6 +1634,9 @@
                         `(~'-seq [this#] (seq (concat [~@(map #(core/list `vector (keyword %) %) base-fields)]
                                                 ~'__extmap)))
 
+                        'IIterable
+                        `(~'-iterator [~gs] (RecordIter. 0 ~gs ~(count base-fields) [~@(map keyword base-fields)]  (-iterator ~'__extmap) ))
+
                         'IPrintWithWriter
                         `(~'-pr-writer [this# writer# opts#]
                            (let [pr-pair# (fn [keyval#] (pr-sequential-writer writer# pr-writer "" " " "" opts# keyval#))]

src/test/cljs/cljs/core_test.cljs

@@ -1418,6 +1418,43 @@
     (is (.equiv #{:cat :dog :bird} #{:cat :dog :bird}))
     ))
 
+(defn seq-iter-match
+  [coll]
+  (let [i (-iterator coll)]
+    (loop [s (seq coll)
+           n 0]
+      (if (seq s)
+        (do
+          (when-not (.hasNext i)
+            (throw
+              (js/Error.
+                (str  "Iterator exhausted before seq at(" n ")" ))))
+          (let [iv (.next i)
+                sv (first s)]
+           (when-not (= iv sv)
+            (throw
+              (js/Error.
+                (str "Iterator value " iv " and seq value " sv " did not match at ( "  n ")")))))
+          (recur (rest s) (inc n)))
+        (if (.hasNext i)
+          (throw
+            (js/Error.
+              (str  "Seq exhausted before iterator at (" n ")")))
+          true)))))
+
+(defrecord TestIterRec [a b])
+
+(deftest coll-iter-seq-match
+  (testing "Direct iterators match sequences"
+    (let [test-map (apply hash-map (range 200))
+          test-set (apply hash-set (range 200))
+          test-queue (into cljs.core.PersistentQueue.EMPTY (vec (range 100)))
+          test-record (into (TestIterRec. 1 2) {:c 3 :d 4})]
+      (is (= true (seq-iter-match test-map)))
+      (is (= true (seq-iter-match test-set)))
+      (is (= true (seq-iter-match test-queue)))
+      (is (= true (seq-iter-match test-record))))))
+
 (deftest test-es6-interfaces
   (testing "ES6 collection interfaces"
     (let [iter (es6-iterator [1 2 3])]