🚴 perf(append): Skip one tree level.

Author: make-github-pseudonymous-again

src/0-core/_fast/_fill_right.js

@@ -0,0 +1,71 @@
+import assert from 'assert';
+
+import {One} from '../../1-digit/1-One.js';
+import {Two} from '../../1-digit/2-Two.js';
+import {Three} from '../../1-digit/3-Three.js';
+import {Four} from '../../1-digit/4-Four.js';
+import {node3} from '../../2-node/node3.js';
+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';
+import {Lazy} from '../../4-lazy/0-Lazy.js';
+
+/**
+ * _fill_right.
+ *
+ * @param {any} M
+ * @param {One|Two|Three|Four} left
+ * @param {Empty|Single|Deep|Lazy} middle
+ * @param {any} x1
+ * @param {Iterator} iterator
+ * @return {Deep}
+ */
+export default function _fill_right(M, left, middle, x1, iterator) {
+	assert(
+		left instanceof One ||
+			left instanceof Two ||
+			left instanceof Three ||
+			left instanceof Four,
+	);
+	assert(
+		middle instanceof Empty ||
+			middle instanceof Single ||
+			middle instanceof Deep ||
+			middle instanceof Lazy,
+	);
+	let event;
+	let x2;
+	let x3;
+	let y1;
+	let y2;
+	let y3;
+	for (;;) {
+		event = iterator.next();
+		if (event.done) return new Deep(M, left, middle, new One(x1));
+		x2 = event.value;
+
+		event = iterator.next();
+		if (event.done) return new Deep(M, left, middle, new Two(x1, x2));
+		x3 = event.value;
+
+		event = iterator.next();
+		if (event.done) return new Deep(M, left, middle, new Three(x1, x2, x3));
+		y1 = event.value;
+
+		middle = middle.push(node3(M, x1, x2, x3));
+
+		event = iterator.next();
+		if (event.done) return new Deep(M, left, middle, new One(y1));
+		y2 = event.value;
+
+		event = iterator.next();
+		if (event.done) return new Deep(M, left, middle, new Two(y1, y2));
+		y3 = event.value;
+
+		event = iterator.next();
+		if (event.done) return new Deep(M, left, middle, new Three(y1, y2, y3));
+		x1 = event.value;
+
+		middle = middle.push(node3(M, y1, y2, y3));
+	}
+}

src/0-core/_fast/_from_by_filling.js

@@ -0,0 +1,22 @@
+import {One} from '../../1-digit/1-One.js';
+import {Empty} from '../../3-tree/implementations/0-Empty.js';
+import {Single} from '../../3-tree/implementations/1-Single.js';
+import {cache} from '../measure/cache.js';
+import _fill_right from './_fill_right.js';
+
+export default function _form_by_filling(M, iterable) {
+	const it = iterable[Symbol.iterator]();
+
+	let event = it.next();
+	if (event.done) return new Empty(M);
+	const a = event.value;
+
+	event = it.next();
+	if (event.done) return new Single(M, a);
+	const b = event.value;
+
+	const left = new One(a);
+	const middle = new Empty(cache(M));
+
+	return _fill_right(M, left, middle, b, it);
+}

src/3-tree/base/Tree.js

@@ -1,4 +1,4 @@
-import {append, prepend} from '../../0-core/index.js';
+import {prepend} from '../../0-core/index.js';
 
 /**
  * Base class for all implementations.
@@ -76,9 +76,9 @@ Tree.prototype.dropUntil = function (predicate) {
  *
  * @returns {Tree} The output tree.
  */
-Tree.prototype.append = function (iterable) {
-	return append(this, iterable);
-};
+// Tree.prototype.append = function (iterable) {
+// return append(this, iterable);
+// };
 
 /**
  * Returns a tree that contains all values of the input iterable in-order

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

@@ -3,6 +3,7 @@ import {Tree} from '../base/index.js';
 import {_EMPTY} from '../../0-core/index.js';
 import {_from_medium_list} from '../../0-core/_fast/_from_medium_list.js';
 import _append_small_list from '../../0-core/_fast/_append_small_list.js';
+import _from_by_filling from '../../0-core/_fast/_from_by_filling.js';
 import {Single, Deep} from './index.js';
 
 export function Empty(M) {
@@ -44,6 +45,10 @@ Empty.prototype.cons = function (value) {
 	return new Single(this.M, value);
 };
 
+Empty.prototype.append = function (iterable) {
+	return _from_by_filling(this.M, iterable);
+};
+
 Empty.prototype.concat = function (other) {
 	return other;
 };

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

@@ -4,6 +4,7 @@ import {cache, Split} from '../../0-core/index.js';
 import {One} from '../../1-digit/index.js';
 import _append_small_list from '../../0-core/_fast/_append_small_list.js';
 import {_from_medium_list} from '../../0-core/_fast/_from_medium_list.js';
+import _fill_right from '../../0-core/_fast/_fill_right.js';
 import {Empty, Deep} from './index.js';
 
 export function Single(M, value) {
@@ -56,6 +57,19 @@ Single.prototype.push = function (value) {
 	);
 };
 
+Single.prototype.append = function (iterable) {
+	const it = iterable[Symbol.iterator]();
+
+	const event = it.next();
+	if (event.done) return this;
+	const x1 = event.value;
+
+	const left = new One(this.a);
+	const middle = new Empty(cache(this.M));
+
+	return _fill_right(this.M, left, middle, x1, it);
+};
+
 Single.prototype.concat = function (other) {
 	return other.cons(this.a);
 };

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

@@ -11,6 +11,7 @@ import {
 import {One, Two, Four} from '../../1-digit/index.js';
 import {delay, Lazy} from '../../4-lazy/index.js';
 import _prepend_small_list from '../../0-core/_fast/_prepend_small_list.js';
+import _fill_right from '../../0-core/_fast/_fill_right.js';
 import {Empty} from './index.js';
 
 export function Deep(M, left, middle, right) {
@@ -109,6 +110,22 @@ Deep.prototype.push = function (value) {
 	return new Deep(this.M, this.left, this.middle, this.right.push(value));
 };
 
+Deep.prototype.append = function (iterable) {
+	const it = iterable[Symbol.iterator]();
+
+	let event = it.next();
+	if (event.done) return this;
+	const a = event.value;
+
+	event = it.next();
+	if (event.done) return this.push(a);
+	const b = event.value;
+
+	const middle = this.middle.push(this.right._nodes(this.M, new One(a)));
+
+	return _fill_right(this.M, this.left, middle, b, it);
+};
+
 Deep.prototype.concat = function (other) {
 	return other._concat_with_deep(this);
 };

src/4-lazy/0-Lazy.js

@@ -56,6 +56,10 @@ Lazy.prototype.split = function (p) {
 	return this.force().split(p);
 };
 
+Lazy.prototype.append = function (iterable) {
+	return this.force().append(iterable);
+};
+
 Lazy.prototype.concat = function (other) {
 	return this.force().concat(other);
 };