Add [Symbol.iterator] to CachedAsyncIterable

The [Symbol.iterator] method returns a synchronous iterator over the elements
cached by the CachedAsyncIterable instance.

Author: stasm

src/cached_async_iterable.mjs

@@ -23,6 +23,34 @@ export default class CachedAsyncIterable {
         this.seen = [];
     }
 
+    /**
+     * Synchronous iterator over the cached elements.
+     *
+     * Return a generator object implementing the iterator protocol over the
+     * cached elements of the original (async or sync) iterable.
+     */
+    [Symbol.iterator]() {
+        const {seen} = this;
+        let cur = 0;
+
+        return {
+            next() {
+                if (seen.length === cur) {
+                    return {value: undefined, done: true};
+                }
+                return seen[cur++];
+            }
+        };
+    }
+
+    /**
+     * Asynchronous iterator caching the yielded elements.
+     *
+     * Elements yielded by the original iterable will be cached and available
+     * synchronously. Returns an async generator object implementing the
+     * iterator protocol over the elements of the original (async or sync)
+     * iterable.
+     */
     [Symbol.asyncIterator]() {
         const { seen, iterator } = this;
         let cur = 0;

test/cached_async_iterable_test.js

@@ -55,6 +55,75 @@ suite("CachedAsyncIterable", function() {
         });
     });
 
+    suite("sync iteration over cached elements", function(){
+        let o1, o2;
+
+        suiteSetup(function() {
+            o1 = Object();
+            o2 = Object();
+        });
+
+        test("sync iterable with no cached elements yet", function() {
+            function *generate() {
+                yield *[o1, o2];
+            }
+
+            const iterable = new CachedAsyncIterable(generate());
+            assert.deepEqual([...iterable], []);
+        });
+
+        test("sync iterable with a few elements cached so far", async function() {
+            function *generate() {
+                yield *[o1, o2];
+            }
+
+            const iterable = new CachedAsyncIterable(generate());
+            await iterable.touchNext();
+            assert.deepEqual([...iterable], [o1]);
+        });
+
+        test("iterable with all cached elements", async function() {
+            function *generate() {
+                yield *[o1, o2];
+            }
+
+            const iterable = new CachedAsyncIterable(generate());
+            await iterable.touchNext();
+            await iterable.touchNext();
+            assert.deepEqual([...iterable], [o1, o2]);
+        });
+
+        test("async iterable with no cached elements yet", async function() {
+            async function *generate() {
+                yield *[o1, o2];
+            }
+
+            const iterable = new CachedAsyncIterable(generate());
+            assert.deepEqual([...iterable], []);
+        });
+
+        test("async iterable with a few elements cached so far", async function() {
+            async function *generate() {
+                yield *[o1, o2];
+            }
+
+            const iterable = new CachedAsyncIterable(generate());
+            await iterable.touchNext();
+            assert.deepEqual([...iterable], [o1]);
+        });
+
+        test("async iterable with all cached elements", async function() {
+            async function *generate() {
+                yield *[o1, o2];
+            }
+
+            const iterable = new CachedAsyncIterable(generate());
+            await iterable.touchNext();
+            await iterable.touchNext();
+            assert.deepEqual([...iterable], [o1, o2]);
+        });
+    });
+
     suite("async iteration", function(){
         let o1, o2;