🚴 perf(DeepIterator): Avoid creating many temporary arrays.

Author: make-github-pseudonymous-again

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

@@ -11,22 +11,21 @@ import DeepIterator, {DOWNWARD} from './DeepIterator.js';
  */
 export default function BackwardIterator(tree) {
 	assert(tree instanceof Deep);
-	this._stack = tree._right._list();
-	this._level = this._stack.map(() => 0);
-	this._tree = tree;
+	this._stack = [];
+	this._level = [];
 	this._direction = DOWNWARD;
 	this._currentLevel = 0;
-	this._treeStack = [];
+	this._treeStack = [tree];
 }
 
 BackwardIterator.prototype = new DeepIterator();
 
-BackwardIterator.prototype._downwardStep = function () {
-	this._stack = this._tree._right._list();
+BackwardIterator.prototype._downwardStep = function (tree) {
+	tree._right._backward(this);
 };
 
 BackwardIterator.prototype._upwardStep = function () {
-	this._stack = this._tree._left._list();
+	this._treeStack.pop()._left._backward(this);
 };
 
 BackwardIterator.prototype._traverse = function (level, x) {

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

@@ -29,32 +29,30 @@ DeepIterator.prototype.next = function () {
 		// 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();
+				// eslint-disable-next-line no-case-declarations
+				const tree = this._treeStack.pop()._force();
+				if (tree instanceof Deep) {
+					this._downwardStep(tree);
 					++this._currentLevel;
-					this._level = this._stack.map(() => this._currentLevel);
+					this._treeStack.push(tree, tree._middle);
 					break;
 				} else {
+					assert(this._treeStack.length >= 1);
 					this._direction = UPWARD;
-					if (this._tree._middle instanceof Single) {
-						this._stack = [this._tree._middle.a];
-						this._level = [this._currentLevel + 1];
+					if (tree instanceof Single) {
+						this._stack.push(tree.a);
+						this._level.push(this._currentLevel);
 						break;
 					}
 
-					assert(this._tree._middle instanceof Empty);
+					assert(tree instanceof Empty);
 				}
 
 			case UPWARD:
-				if (this._currentLevel === -1) return {done: true};
-				assert(this._tree instanceof Deep);
+				if (this._currentLevel === 0) return {done: true};
+				assert(this._treeStack[this._treeStack.length - 1] instanceof Deep);
+				--this._currentLevel;
 				this._upwardStep();
-				this._level = this._stack.map(() => this._currentLevel);
-
-				this._tree = --this._currentLevel === -1 ? null : this._treeStack.pop();
 		}
 		/* eslint-enable no-fallthrough */
 	}

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

@@ -11,22 +11,21 @@ import DeepIterator, {DOWNWARD} from './DeepIterator.js';
  */
 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._stack = [];
+	this._level = [];
 	this._direction = DOWNWARD;
 	this._currentLevel = 0;
-	this._treeStack = [];
+	this._treeStack = [tree];
 }
 
 ForwardIterator.prototype = new DeepIterator();
 
-ForwardIterator.prototype._downwardStep = function () {
-	this._stack = this._tree._left._list().reverse();
+ForwardIterator.prototype._downwardStep = function (tree) {
+	tree._left._forward(this);
 };
 
 ForwardIterator.prototype._upwardStep = function () {
-	this._stack = this._tree._right._list().reverse();
+	this._treeStack.pop()._right._forward(this);
 };
 
 ForwardIterator.prototype._traverse = function (level, x) {

src/1-digit/1-One.js

@@ -231,3 +231,12 @@ One.prototype._isolated_tail = function (parent) {
 		parent._right,
 	);
 };
+
+One.prototype._backward =
+	// eslint-disable-next-line no-multi-assign
+	One.prototype._forward = function (iterator) {
+		assert(iterator._stack.length === 0);
+		assert(iterator._level.length === 0);
+		iterator._stack.push(this.a);
+		iterator._level.push(iterator._currentLevel);
+	};

src/1-digit/2-Two.js

@@ -233,3 +233,17 @@ Two.prototype._isolated_tail = function (parent) {
 	assert(parent._left === this);
 	return new Deep(parent.M, this.tail(), parent._middle, parent._right);
 };
+
+Two.prototype._forward = function (iterator) {
+	assert(iterator._stack.length === 0);
+	assert(iterator._level.length === 0);
+	iterator._stack.push(this.b, this.a);
+	iterator._level.push(iterator._currentLevel, iterator._currentLevel);
+};
+
+Two.prototype._backward = function (iterator) {
+	assert(iterator._stack.length === 0);
+	assert(iterator._level.length === 0);
+	iterator._stack.push(this.a, this.b);
+	iterator._level.push(iterator._currentLevel, iterator._currentLevel);
+};

src/1-digit/3-Three.js

@@ -243,3 +243,25 @@ Three.prototype._isolated_tail = function (parent) {
 	assert(parent._left === this);
 	return new Deep(parent.M, this.tail(), parent._middle, parent._right);
 };
+
+Three.prototype._forward = function (iterator) {
+	assert(iterator._stack.length === 0);
+	assert(iterator._level.length === 0);
+	iterator._stack.push(this.c, this.b, this.a);
+	iterator._level.push(
+		iterator._currentLevel,
+		iterator._currentLevel,
+		iterator._currentLevel,
+	);
+};
+
+Three.prototype._backward = function (iterator) {
+	assert(iterator._stack.length === 0);
+	assert(iterator._level.length === 0);
+	iterator._stack.push(this.a, this.b, this.c);
+	iterator._level.push(
+		iterator._currentLevel,
+		iterator._currentLevel,
+		iterator._currentLevel,
+	);
+};

src/1-digit/4-Four.js

@@ -284,3 +284,27 @@ Four.prototype._isolated_tail = function (parent) {
 	assert(parent._left === this);
 	return new Deep(parent.M, this.tail(), parent._middle, parent._right);
 };
+
+Four.prototype._forward = function (iterator) {
+	assert(iterator._stack.length === 0);
+	assert(iterator._level.length === 0);
+	iterator._stack.push(this.d, this.c, this.b, this.a);
+	iterator._level.push(
+		iterator._currentLevel,
+		iterator._currentLevel,
+		iterator._currentLevel,
+		iterator._currentLevel,
+	);
+};
+
+Four.prototype._backward = function (iterator) {
+	assert(iterator._stack.length === 0);
+	assert(iterator._level.length === 0);
+	iterator._stack.push(this.a, this.b, this.c, this.d);
+	iterator._level.push(
+		iterator._currentLevel,
+		iterator._currentLevel,
+		iterator._currentLevel,
+		iterator._currentLevel,
+	);
+};