🚴 perf(iterator/reversed): 5-6x faster iterators.

This also has the benefit of reducing legacy bundle sizes.

Author: make-github-pseudonymous-again

src/0-core/_fast/fast-iterators/1-_EmptyGenerator.js

@@ -3,3 +3,7 @@ export function _EmptyGenerator() {}
 _EmptyGenerator.prototype.next = function () {
 	return {done: true};
 };
+
+_EmptyGenerator.prototype[Symbol.iterator] = function () {
+	return this;
+};

src/0-core/_fast/fast-iterators/BackwardIterator.js

@@ -0,0 +1,43 @@
+import assert from 'assert';
+import {Node2} from '../../../2-node/2-Node2.js';
+import {Node3} from '../../../2-node/3-Node3.js';
+import {Deep} from '../../../3-tree/implementations/2-Deep.js';
+import DeepIterator, {DOWNWARD} from './DeepIterator.js';
+
+/**
+ * BackwardIterator.
+ *
+ * @param {Deep} tree
+ */
+export default function BackwardIterator(tree) {
+	assert(tree instanceof Deep);
+	this._stack = tree._right._list();
+	this._level = this._stack.map(() => 0);
+	this._tree = tree;
+	this._direction = DOWNWARD;
+	this._currentLevel = 0;
+	this._treeStack = [];
+}
+
+BackwardIterator.prototype = new DeepIterator();
+
+BackwardIterator.prototype._downwardStep = function () {
+	this._stack = this._tree._right._list();
+};
+
+BackwardIterator.prototype._upwardStep = function () {
+	this._stack = this._tree._left._list();
+};
+
+BackwardIterator.prototype._traverse = function (level, x) {
+	if (x instanceof Node3) {
+		this._level.push(level, level);
+		this._stack.push(x.a, x.b);
+		return x.c;
+	}
+
+	assert(x instanceof Node2);
+	this._level.push(level);
+	this._stack.push(x.a);
+	return x.b;
+};

src/0-core/_fast/fast-iterators/DeepIterator.js

@@ -0,0 +1,67 @@
+import assert from 'assert';
+import {Empty} from '../../../3-tree/implementations/0-Empty.js';
+import {Single} from '../../../3-tree/implementations/1-Single.js';
+import {Deep} from '../../../3-tree/implementations/2-Deep.js';
+
+export const DOWNWARD = 0;
+export const UPWARD = 1;
+
+export default function DeepIterator() {}
+
+DeepIterator.prototype._pop = function () {
+	assert(this._stack.length >= 1);
+	assert(this._stack.length === this._level.length);
+	let x = this._stack.pop();
+	let level = this._level.pop();
+
+	for (;;) {
+		assert(this._stack.length === this._level.length);
+		assert(Number.isInteger(level) && level >= 0);
+		if (level === 0) return {done: false, value: x};
+
+		x = this._traverse(--level, x);
+	}
+};
+
+DeepIterator.prototype.next = function () {
+	if (this._stack.length === 0) {
+		/* eslint-disable no-fallthrough */
+		// eslint-disable-next-line default-case
+		switch (this._direction) {
+			case DOWNWARD:
+				this._tree._middle = this._tree._middle._force();
+				if (this._tree._middle instanceof Deep) {
+					this._treeStack.push(this._tree);
+					this._tree = this._tree._middle;
+					this._downwardStep();
+					++this._currentLevel;
+					this._level = this._stack.map(() => this._currentLevel);
+					break;
+				} else {
+					this._direction = UPWARD;
+					if (this._tree._middle instanceof Single) {
+						this._stack = [this._tree._middle.a];
+						this._level = [this._currentLevel + 1];
+						break;
+					}
+
+					assert(this._tree._middle instanceof Empty);
+				}
+
+			case UPWARD:
+				if (this._currentLevel === -1) return {done: true};
+				assert(this._tree instanceof Deep);
+				this._upwardStep();
+				this._level = this._stack.map(() => this._currentLevel);
+
+				this._tree = --this._currentLevel === -1 ? null : this._treeStack.pop();
+		}
+		/* eslint-enable no-fallthrough */
+	}
+
+	return this._pop();
+};
+
+DeepIterator.prototype[Symbol.iterator] = function () {
+	return this;
+};

src/0-core/_fast/fast-iterators/ForwardIterator.js

@@ -0,0 +1,43 @@
+import assert from 'assert';
+import {Node2} from '../../../2-node/2-Node2.js';
+import {Node3} from '../../../2-node/3-Node3.js';
+import {Deep} from '../../../3-tree/implementations/2-Deep.js';
+import DeepIterator, {DOWNWARD} from './DeepIterator.js';
+
+/**
+ * ForwardIterator.
+ *
+ * @param {Deep} tree
+ */
+export default function ForwardIterator(tree) {
+	assert(tree instanceof Deep);
+	this._stack = tree._left._list().reverse();
+	this._level = this._stack.map(() => 0);
+	this._tree = tree;
+	this._direction = DOWNWARD;
+	this._currentLevel = 0;
+	this._treeStack = [];
+}
+
+ForwardIterator.prototype = new DeepIterator();
+
+ForwardIterator.prototype._downwardStep = function () {
+	this._stack = this._tree._left._list().reverse();
+};
+
+ForwardIterator.prototype._upwardStep = function () {
+	this._stack = this._tree._right._list().reverse();
+};
+
+ForwardIterator.prototype._traverse = function (level, x) {
+	if (x instanceof Node3) {
+		this._level.push(level, level);
+		this._stack.push(x.c, x.b);
+		return x.a;
+	}
+
+	assert(x instanceof Node2);
+	this._level.push(level);
+	this._stack.push(x.b);
+	return x.a;
+};

src/1-digit/0-Digit.js

@@ -1,9 +1 @@
 export function Digit() {}
-
-Digit.prototype[Symbol.iterator] = function () {
-	return this._list()[Symbol.iterator]();
-};
-
-Digit.prototype.reversed = function () {
-	return this._list().reverse()[Symbol.iterator]();
-};

src/2-node/2-Node2.js

@@ -6,14 +6,6 @@ export function Node2(v, a, b) {
 	this.b = b;
 }
 
-Node2.prototype[Symbol.iterator] = function () {
-	return [this.a, this.b][Symbol.iterator]();
-};
-
-Node2.prototype.reversed = function () {
-	return [this.b, this.a][Symbol.iterator]();
-};
-
 Node2.prototype.measure = function () {
 	return this.v;
 };

src/2-node/3-Node3.js

@@ -7,14 +7,6 @@ export function Node3(v, a, b, c) {
 	this.c = c;
 }
 
-Node3.prototype[Symbol.iterator] = function () {
-	return [this.a, this.b, this.c][Symbol.iterator]();
-};
-
-Node3.prototype.reversed = function () {
-	return [this.c, this.b, this.a][Symbol.iterator]();
-};
-
 Node3.prototype.measure = function () {
 	return this.v;
 };

src/3-tree/implementations/0-Empty.js

@@ -59,11 +59,11 @@ Empty.prototype.concat = function (other) {
 	return other;
 };
 
-Empty.prototype[Symbol.iterator] = function () {
-	return _EMPTY;
-};
-
-Empty.prototype.reversed = function* () {};
+Empty.prototype[Symbol.iterator] =
+	// eslint-disable-next-line no-multi-assign
+	Empty.prototype.reversed = function () {
+		return _EMPTY;
+	};
 
 /**
  * It is assumed that p(i+|this|) is true.

src/3-tree/implementations/1-Single.js

@@ -76,8 +76,8 @@ Single.prototype.concat = function (other) {
 
 Single.prototype[Symbol.iterator] =
 	// eslint-disable-next-line no-multi-assign
-	Single.prototype.reversed = function* () {
-		yield this.a;
+	Single.prototype.reversed = function () {
+		return [this.a][Symbol.iterator]();
 	};
 
 /**

src/3-tree/implementations/2-Deep.js

@@ -8,6 +8,8 @@ import isSameMeasure from '../../_debug/isSameMeasure.js';
 import _from_by_filling from '../../0-core/_fast/_from_by_filling.js';
 import empty from '../../5-api/empty.js';
 import delayApp3RecurseStep from '../../4-lazy/delayApp3RecurseStep.js';
+import ForwardIterator from '../../0-core/_fast/fast-iterators/ForwardIterator.js';
+import BackwardIterator from '../../0-core/_fast/fast-iterators/BackwardIterator.js';
 import {Empty} from './0-Empty.js';
 import {Single} from './1-Single.js';
 
@@ -98,16 +100,12 @@ Deep.prototype.concat = function (other) {
 	return other._concat_with_deep(this);
 };
 
-Deep.prototype[Symbol.iterator] = function* () {
-	yield* this._left;
-	for (const node of this._middle) yield* node;
-	yield* this._right;
+Deep.prototype[Symbol.iterator] = function () {
+	return new ForwardIterator(this);
 };
 
-Deep.prototype.reversed = function* () {
-	yield* this._right.reversed();
-	for (const node of this._middle.reversed()) yield* node.reversed();
-	yield* this._left.reversed();
+Deep.prototype.reversed = function () {
+	return new BackwardIterator(this);
 };
 
 /**