Make CachedIterable a subclass of Array

stasm · stasm · commit b5eedbb3e3ee · 2018-06-08T16:31:31.000+02:00
diff --git a/src/cached_async_iterable.mjs b/src/cached_async_iterable.mjs
@@ -32,15 +32,15 @@ export default class CachedAsyncIterable extends CachedIterable {
      * cached elements of the original (async or sync) iterable.
      */
     [Symbol.iterator]() {
-        const {seen} = this;
+        const cached = this;
         let cur = 0;
 
         return {
             next() {
-                if (seen.length === cur) {
+                if (cached.length === cur) {
                     return {value: undefined, done: true};
                 }
-                return seen[cur++];
+                return cached[cur++];
             }
         };
     }
@@ -54,15 +54,15 @@ export default class CachedAsyncIterable extends CachedIterable {
      * iterable.
      */
     [Symbol.asyncIterator]() {
-        const { seen, iterator } = this;
+        const cached = this;
         let cur = 0;
 
         return {
             async next() {
-                if (seen.length <= cur) {
-                    seen.push(await iterator.next());
+                if (cached.length <= cur) {
+                    cached.push(await cached.iterator.next());
                 }
-                return seen[cur++];
+                return cached[cur++];
             }
         };
     }
@@ -74,15 +74,14 @@ export default class CachedAsyncIterable extends CachedIterable {
      * @param {number} count - number of elements to consume
      */
     async touchNext(count = 1) {
-        const { seen, iterator } = this;
         let idx = 0;
         while (idx++ < count) {
-            if (seen.length === 0 || seen[seen.length - 1].done === false) {
-                seen.push(await iterator.next());
+            if (this.length === 0 || this[this.length - 1].done === false) {
+                this.push(await this.iterator.next());
             }
         }
         // Return the last cached {value, done} object to allow the calling
         // code to decide if it needs to call touchNext again.
-        return seen[seen.length - 1];
+        return this[this.length - 1];
     }
 }
diff --git a/src/cached_iterable.mjs b/src/cached_iterable.mjs
@@ -1,17 +1,7 @@
 /*
  * Base CachedIterable class.
  */
-export default class CachedIterable {
-    /**
-     * Create an `CachedIterable` instance.
-     *
-     * @param {Iterable} iterable
-     * @returns {CachedIterable}
-     */
-    constructor() {
-        this.seen = [];
-    }
-
+export default class CachedIterable extends Array {
     /**
      * Create a `CachedIterable` instance from an iterable or, if another
      * instance of `CachedIterable` is passed, return it without any
diff --git a/src/cached_sync_iterable.mjs b/src/cached_sync_iterable.mjs
@@ -24,15 +24,15 @@ export default class CachedSyncIterable extends CachedIterable {
     }
 
     [Symbol.iterator]() {
-        const { seen, iterator } = this;
+        const cached = this;
         let cur = 0;
 
         return {
             next() {
-                if (seen.length <= cur) {
-                    seen.push(iterator.next());
+                if (cached.length <= cur) {
+                    cached.push(cached.iterator.next());
                 }
-                return seen[cur++];
+                return cached[cur++];
             }
         };
     }
@@ -44,15 +44,14 @@ export default class CachedSyncIterable extends CachedIterable {
      * @param {number} count - number of elements to consume
      */
     touchNext(count = 1) {
-        const { seen, iterator } = this;
         let idx = 0;
         while (idx++ < count) {
-            if (seen.length === 0 || seen[seen.length - 1].done === false) {
-                seen.push(iterator.next());
+            if (this.length === 0 || this[this.length - 1].done === false) {
+                this.push(this.iterator.next());
             }
         }
         // Return the last cached {value, done} object to allow the calling
         // code to decide if it needs to call touchNext again.
-        return seen[seen.length - 1];
+        return this[this.length - 1];
     }
 }
diff --git a/test/cached_async_iterable_test.js b/test/cached_async_iterable_test.js
@@ -186,33 +186,33 @@ suite("CachedAsyncIterable", function() {
 
         test("consumes an element into the cache", async function() {
             const iterable = new CachedAsyncIterable(generateMessages());
-            assert.equal(iterable.seen.length, 0);
+            assert.equal(iterable.length, 0);
             await iterable.touchNext();
-            assert.equal(iterable.seen.length, 1);
+            assert.equal(iterable.length, 1);
         });
 
         test("allows to consume multiple elements into the cache", async function() {
             const iterable = new CachedAsyncIterable(generateMessages());
             await iterable.touchNext();
             await iterable.touchNext();
-            assert.equal(iterable.seen.length, 2);
+            assert.equal(iterable.length, 2);
         });
 
         test("allows to consume multiple elements at once", async function() {
             const iterable = new CachedAsyncIterable(generateMessages());
             await iterable.touchNext(2);
-            assert.equal(iterable.seen.length, 2);
+            assert.equal(iterable.length, 2);
         });
 
         test("stops at the last element", async function() {
             const iterable = new CachedAsyncIterable(generateMessages());
             await iterable.touchNext();
             await iterable.touchNext();
             await iterable.touchNext();
-            assert.equal(iterable.seen.length, 3);
+            assert.equal(iterable.length, 3);
 
             await iterable.touchNext();
-            assert.equal(iterable.seen.length, 3);
+            assert.equal(iterable.length, 3);
         });
 
         test("works on an empty iterable", async function() {
@@ -223,7 +223,7 @@ suite("CachedAsyncIterable", function() {
             await iterable.touchNext();
             await iterable.touchNext();
             await iterable.touchNext();
-            assert.equal(iterable.seen.length, 1);
+            assert.equal(iterable.length, 1);
         });
 
         test("iteration for such cache works", async function() {
diff --git a/test/cached_sync_iterable_test.js b/test/cached_sync_iterable_test.js
@@ -106,41 +106,41 @@ suite("CachedSyncIterable", function() {
 
         test("consumes an element into the cache", function() {
             const iterable = new CachedSyncIterable([o1, o2]);
-            assert.equal(iterable.seen.length, 0);
+            assert.equal(iterable.length, 0);
             iterable.touchNext();
-            assert.equal(iterable.seen.length, 1);
+            assert.equal(iterable.length, 1);
         });
 
         test("allows to consume multiple elements into the cache", function() {
             const iterable = new CachedSyncIterable([o1, o2]);
             iterable.touchNext();
             iterable.touchNext();
-            assert.equal(iterable.seen.length, 2);
+            assert.equal(iterable.length, 2);
         });
 
         test("allows to consume multiple elements at once", function() {
             const iterable = new CachedSyncIterable([o1, o2]);
             iterable.touchNext(2);
-            assert.equal(iterable.seen.length, 2);
+            assert.equal(iterable.length, 2);
         });
 
         test("stops at the last element", function() {
             const iterable = new CachedSyncIterable([o1, o2]);
             iterable.touchNext();
             iterable.touchNext();
             iterable.touchNext();
-            assert.equal(iterable.seen.length, 3);
+            assert.equal(iterable.length, 3);
 
             iterable.touchNext();
-            assert.equal(iterable.seen.length, 3);
+            assert.equal(iterable.length, 3);
         });
 
         test("works on an empty iterable", function() {
             const iterable = new CachedSyncIterable([]);
             iterable.touchNext();
             iterable.touchNext();
             iterable.touchNext();
-            assert.equal(iterable.seen.length, 1);
+            assert.equal(iterable.length, 1);
         });
 
         test("iteration for such cache works", function() {

Original file line number	Diff line number	Diff line change
`@@ -32,15 +32,15 @@ export default class CachedAsyncIterable extends CachedIterable {`
`32`	`32`	`* cached elements of the original (async or sync) iterable.`
`33`	`33`	`*/`
`34`	`34`	`[Symbol.iterator]() {`
`35`		`- const {seen} = this;`
	`35`	`+ const cached = this;`
`36`	`36`	`let cur = 0;`
`37`	`37`
`38`	`38`	`return {`
`39`	`39`	`next() {`
`40`		`- if (seen.length === cur) {`
	`40`	`+ if (cached.length === cur) {`
`41`	`41`	`return {value: undefined, done: true};`
`42`	`42`	`}`
`43`		`- return seen[cur++];`
	`43`	`+ return cached[cur++];`
`44`	`44`	`}`
`45`	`45`	`};`
`46`	`46`	`}`
`@@ -54,15 +54,15 @@ export default class CachedAsyncIterable extends CachedIterable {`
`54`	`54`	`* iterable.`
`55`	`55`	`*/`
`56`	`56`	`[Symbol.asyncIterator]() {`
`57`		`- const { seen, iterator } = this;`
	`57`	`+ const cached = this;`
`58`	`58`	`let cur = 0;`
`59`	`59`
`60`	`60`	`return {`
`61`	`61`	`async next() {`
`62`		`- if (seen.length <= cur) {`
`63`		`- seen.push(await iterator.next());`
	`62`	`+ if (cached.length <= cur) {`
	`63`	`+ cached.push(await cached.iterator.next());`
`64`	`64`	`}`
`65`		`- return seen[cur++];`
	`65`	`+ return cached[cur++];`
`66`	`66`	`}`
`67`	`67`	`};`
`68`	`68`	`}`
`@@ -74,15 +74,14 @@ export default class CachedAsyncIterable extends CachedIterable {`
`74`	`74`	`* @param {number} count - number of elements to consume`
`75`	`75`	`*/`
`76`	`76`	`async touchNext(count = 1) {`
`77`		`- const { seen, iterator } = this;`
`78`	`77`	`let idx = 0;`
`79`	`78`	`while (idx++ < count) {`
`80`		`- if (seen.length === 0 \|\| seen[seen.length - 1].done === false) {`
`81`		`- seen.push(await iterator.next());`
	`79`	`+ if (this.length === 0 \|\| this[this.length - 1].done === false) {`
	`80`	`+ this.push(await this.iterator.next());`
`82`	`81`	`}`
`83`	`82`	`}`
`84`	`83`	`// Return the last cached {value, done} object to allow the calling`
`85`	`84`	`// code to decide if it needs to call touchNext again.`
`86`		`- return seen[seen.length - 1];`
	`85`	`+ return this[this.length - 1];`
`87`	`86`	`}`
`88`	`87`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,15 +24,15 @@ export default class CachedSyncIterable extends CachedIterable {`
`24`	`24`	`}`
`25`	`25`
`26`	`26`	`[Symbol.iterator]() {`
`27`		`- const { seen, iterator } = this;`
	`27`	`+ const cached = this;`
`28`	`28`	`let cur = 0;`
`29`	`29`
`30`	`30`	`return {`
`31`	`31`	`next() {`
`32`		`- if (seen.length <= cur) {`
`33`		`- seen.push(iterator.next());`
	`32`	`+ if (cached.length <= cur) {`
	`33`	`+ cached.push(cached.iterator.next());`
`34`	`34`	`}`
`35`		`- return seen[cur++];`
	`35`	`+ return cached[cur++];`
`36`	`36`	`}`
`37`	`37`	`};`
`38`	`38`	`}`
`@@ -44,15 +44,14 @@ export default class CachedSyncIterable extends CachedIterable {`
`44`	`44`	`* @param {number} count - number of elements to consume`
`45`	`45`	`*/`
`46`	`46`	`touchNext(count = 1) {`
`47`		`- const { seen, iterator } = this;`
`48`	`47`	`let idx = 0;`
`49`	`48`	`while (idx++ < count) {`
`50`		`- if (seen.length === 0 \|\| seen[seen.length - 1].done === false) {`
`51`		`- seen.push(iterator.next());`
	`49`	`+ if (this.length === 0 \|\| this[this.length - 1].done === false) {`
	`50`	`+ this.push(this.iterator.next());`
`52`	`51`	`}`
`53`	`52`	`}`
`54`	`53`	`// Return the last cached {value, done} object to allow the calling`
`55`	`54`	`// code to decide if it needs to call touchNext again.`
`56`		`- return seen[seen.length - 1];`
	`55`	`+ return this[this.length - 1];`
`57`	`56`	`}`
`58`	`57`	`}`