CLJS-2693: Have Range implement IChunkedSeq

This set of changes mirrors those in Clojure surrounding LongRange and
LongChunk. In particular, range is modified to follow the 3-arg
LongRange/create.

The previous next implementation is preserved. (The Clojure
implemenation forces a chunk for each next call, which, in
ClojureScript, slows down algorithms like doall which walk the seq.)

RangeChunk does not implement IReduce because, unlike in Clojure,
ClojureScript doesn't have an internal-reduce which reduces chunked-seq
chunks. (Additionally, reduce for ranges is handled directly by Range.)

Author: mfikes

src/main/cljs/cljs/core.cljs

@@ -9547,6 +9547,27 @@ reduces them without incurring seq initialization"
        (take-while (mk-bound-fn sc start-test start-key)
                    (if ((mk-bound-fn sc end-test end-key) e) s (next s))))))
 
+(deftype RangeChunk [start step count]
+  ICounted
+  (-count [coll] count)
+
+  ISeq
+  (-first [coll] start)
+
+  IIndexed
+  (-nth [coll i]
+    (+ start (* i step)))
+  (-nth [coll i not-found]
+    (if (and (>= i 0) (< i count))
+      (+ start (* i step))
+      not-found))
+
+  IChunk
+  (-drop-first [coll]
+    (if (<= count 1)
+      (throw (js/Error. "-drop-first of empty chunk"))
+      (RangeChunk. (+ start step) step (dec count)))))
+
 (deftype RangeIterator [^:mutable i end step]
   Object
   (hasNext [_]
@@ -9558,7 +9579,7 @@ reduces them without incurring seq initialization"
       (set! i (+ i step))
       ret)))
 
-(deftype Range [meta start end step ^:mutable __hash]
+(deftype Range [meta start end step ^:mutable chunk ^:mutable chunk-next ^:mutable __hash]
   Object
   (toString [coll]
     (pr-str* coll))
@@ -9572,30 +9593,34 @@ reduces them without incurring seq initialization"
     (-lastIndexOf coll x (count coll)))
   (lastIndexOf [coll x start]
     (-lastIndexOf coll x start))
+  (forceChunk [coll]
+    (when (nil? chunk)
+      (let [count (-count coll)]
+        (if (> count 32)
+          (do
+            (set! chunk-next (Range. nil (+ start (* step 32)) end step nil nil nil))
+            (set! chunk (RangeChunk. start step 32)))
+          (set! chunk (RangeChunk. start step count))))))
 
   ICloneable
-  (-clone [_] (Range. meta start end step __hash))
+  (-clone [_] (Range. meta start end step chunk chunk-next __hash))
 
   IWithMeta
-  (-with-meta [rng meta] (Range. meta start end step __hash))
+  (-with-meta [rng meta] (Range. meta start end step chunk chunk-next __hash))
 
   IMeta
   (-meta [rng] meta)
 
   ISeqable
-  (-seq [rng]
-    (cond
-      (pos? step) (when (< start end) rng)
-      (neg? step) (when (> start end) rng)
-      :else       (when-not (== start end) rng)))
+  (-seq [rng] rng)
 
   ISeq
-  (-first [rng]
-    (when-not (nil? (-seq rng)) start))
+  (-first [rng] start)
   (-rest [rng]
-    (if-not (nil? (-seq rng))
-      (Range. meta (+ start step) end step nil)
-      ()))
+    (let [s (-next rng)]
+      (if (nil? s)
+        ()
+        s)))
 
   IIterable
   (-iterator [_]
@@ -9605,9 +9630,23 @@ reduces them without incurring seq initialization"
   (-next [rng]
     (if (pos? step)
       (when (< (+ start step) end)
-        (Range. meta (+ start step) end step nil))
+        (Range. meta (+ start step) end step nil nil nil))
       (when (> (+ start step) end)
-        (Range. meta (+ start step) end step nil))))
+        (Range. meta (+ start step) end step nil nil nil))))
+
+  IChunkedSeq
+  (-chunked-first [rng]
+    (.forceChunk rng)
+    chunk)
+  (-chunked-rest [rng]
+    (.forceChunk rng)
+    (if (nil? chunk-next)
+      ()
+      chunk-next))
+
+  IChunkedNext
+  (-chunked-next [rng]
+    (seq (-chunked-rest rng)))
 
   ICollection
   (-conj [rng o] (cons o rng))
@@ -9624,9 +9663,7 @@ reduces them without incurring seq initialization"
 
   ICounted
   (-count [rng]
-    (if-not (-seq rng)
-      0
-      (Math/ceil (/ (- end start) step))))
+    (Math/ceil (/ (- end start) step)))
 
   IIndexed
   (-nth [rng n]
@@ -9662,7 +9699,22 @@ reduces them without incurring seq initialization"
   ([] (range 0 (.-MAX_VALUE js/Number) 1))
   ([end] (range 0 end 1))
   ([start end] (range start end 1))
-  ([start end step] (Range. nil start end step nil)))
+  ([start end step]
+   (cond
+     (pos? step)
+     (if (<= end start)
+       ()
+       (Range. nil start end step nil nil nil))
+
+     (neg? step)
+     (if (>= end start)
+       ()
+       (Range. nil start end step nil nil nil))
+
+     :else
+     (if (== end start)
+       ()
+       (repeat start)))))
 
 (defn take-nth
   "Returns a lazy seq of every nth item in coll.  Returns a stateful

src/test/cljs/cljs/core_test.cljs

@@ -1599,6 +1599,23 @@
   ;; Make sure we didn't delete the alpha? fn
   (is (some? alpha-2585?)))
 
+(deftest test-cljs-2693
+  (is (chunked-seq? (range 5)))
+  (is (satisfies? IChunk (chunk-first (range 5))))
+  (is (nil? (chunk-next (range 32))))
+  (is (satisfies? IChunk (chunk-first (chunk-next (range 33)))))
+  (is (satisfies? IChunk (chunk-first (chunk-rest (range 33)))))
+  (is (not (chunked-seq? (range 2 -2 0))))
+  (is (chunked-seq? (range)))
+  (is (= 5 (count (chunk-first (range 5)))))
+  (is (= 32 (count (chunk-first (range)))))
+  (is (= 17 (nth (chunk-first (range 100)) 17)))
+  (is (= ::not-found (nth (chunk-first (range 100)) 35 ::not-found)))
+  (is (= 0 (first (range 5))))
+  (is (= 1 (second (range 5))))
+  (is (= (range 1 5) (rest (range 5))))
+  (is (= (range 1 5) (next (range 5)))))
+
 (defn fn-2741* ([x]) ([x y]))
 (def fn-2741 fn-2741*)