Add a static CachedIterable.from method.

It behaves similar to the constructor. It can also detect instances of
CachedSyncIterable and CachedAsyncIterable passed as the argument and if the
argument's class matches the class from() was called on, it returns the
argument unmodified.

Author: stasm

src/cached_async_iterable.mjs

@@ -1,26 +1,28 @@
+import CachedIterable from "./cached_iterable.mjs";
+
 /*
  * CachedAsyncIterable caches the elements yielded by an async iterable.
  *
  * It can be used to iterate over an iterable many times without depleting the
  * iterable.
  */
-export default class CachedAsyncIterable {
+export default class CachedAsyncIterable extends CachedIterable {
     /**
      * Create an `CachedAsyncIterable` instance.
      *
      * @param {Iterable} iterable
      * @returns {CachedAsyncIterable}
      */
     constructor(iterable) {
+        super();
+
         if (Symbol.asyncIterator in Object(iterable)) {
             this.iterator = iterable[Symbol.asyncIterator]();
         } else if (Symbol.iterator in Object(iterable)) {
             this.iterator = iterable[Symbol.iterator]();
         } else {
             throw new TypeError("Argument must implement the iteration protocol.");
         }
-
-        this.seen = [];
     }
 
     /**

src/cached_iterable.mjs

@@ -0,0 +1,30 @@
+/*
+ * Base CachedIterable class.
+ */
+export default class CachedIterable {
+    /**
+     * Create an `CachedIterable` instance.
+     *
+     * @param {Iterable} iterable
+     * @returns {CachedIterable}
+     */
+    constructor() {
+        this.seen = [];
+    }
+
+    /**
+     * Create a `CachedIterable` instance from an iterable or, if another
+     * instance of `CachedIterable` is passed, return it without any
+     * modifications.
+     *
+     * @param {Iterable} iterable
+     * @returns {CachedIterable}
+     */
+    static from(iterable) {
+        if (iterable instanceof this) {
+            return iterable;
+        }
+
+        return new this(iterable);
+    }
+}

src/cached_sync_iterable.mjs

@@ -1,24 +1,26 @@
+import CachedIterable from "./cached_iterable.mjs";
+
 /*
  * CachedSyncIterable caches the elements yielded by an iterable.
  *
  * It can be used to iterate over an iterable many times without depleting the
  * iterable.
  */
-export default class CachedSyncIterable {
+export default class CachedSyncIterable extends CachedIterable {
     /**
      * Create an `CachedSyncIterable` instance.
      *
      * @param {Iterable} iterable
      * @returns {CachedSyncIterable}
      */
     constructor(iterable) {
+        super();
+
         if (Symbol.iterator in Object(iterable)) {
             this.iterator = iterable[Symbol.iterator]();
         } else {
             throw new TypeError("Argument must implement the iteration protocol.");
         }
-
-        this.seen = [];
     }
 
     [Symbol.iterator]() {

test/cached_async_iterable_test.js

@@ -55,6 +55,22 @@ suite("CachedAsyncIterable", function() {
         });
     });
 
+    suite("from()", function() {
+        test("pass any iterable", async function() {
+            const iterable = CachedAsyncIterable.from([1, 2]);
+            // No cached elements yet.
+            assert.deepEqual([...iterable], []);
+            // Deplete the original iterable.
+            assert.deepEqual(await toArray(iterable), [1, 2]);
+        });
+
+        test("pass another CachedAsyncIterable", function() {
+            const iterable1 = new CachedAsyncIterable([1, 2]);
+            const iterable2 = CachedAsyncIterable.from(iterable1);
+            assert.equal(iterable1, iterable2);
+        });
+    });
+
     suite("sync iteration over cached elements", function(){
         let o1, o2;
 

test/cached_sync_iterable_test.js

@@ -40,6 +40,19 @@ suite("CachedSyncIterable", function() {
         });
     });
 
+    suite("from()", function() {
+        test("pass any iterable", function() {
+            const iterable = CachedSyncIterable.from([1, 2]);
+            assert.deepEqual([...iterable], [1, 2]);
+        });
+
+        test("pass another CachedSyncIterable", function() {
+            const iterable1 = new CachedSyncIterable([1, 2]);
+            const iterable2 = CachedSyncIterable.from(iterable1);
+            assert.equal(iterable1, iterable2);
+        });
+    });
+
     suite("sync iteration", function(){
         let o1, o2;