🚴 perf(split): Avoid creating temporary arrays.

We immediately instantiate a Digit or null. It's a win-win best deal ever:
  - If we need a Digit, it's there!
  - No need to branch on list.length! So we win even when we need a Tree.

Also we use separate struct DigitSplit to store result of _splitDigit since
member types are not the same as in a tree Split. Maybe should rename Split to
TreeSplit later.

Author: make-github-pseudonymous-again

src/0-core/_fast/_digit.js

@@ -1,8 +1,5 @@
 export * from './_append.js';
 export * from './_deepL.js';
 export * from './_deepR.js';
-export * from './_digit.js';
-export * from './_from_digit.js';
-export * from './_from_small_list.js';
 export * from './_prepend.js';
 export * from './fast-iterators/index.js';

src/0-core/_fast/_from_digit.js

@@ -0,0 +1,17 @@
+import assert from 'assert';
+import {Digit} from '../../1-digit/0-Digit.js';
+
+/**
+ * DigitSplit.
+ *
+ * @param {Digit} left
+ * @param {any} middle
+ * @param {Digit} right
+ */
+export function DigitSplit(left, middle, right) {
+	assert(left === null || left instanceof Digit);
+	assert(right === null || right instanceof Digit);
+	this._left = left;
+	this._middle = middle;
+	this._right = right;
+}

src/0-core/_fast/_from_small_list.js

@@ -1,4 +1,16 @@
+import assert from 'assert';
+import {Tree} from '../../3-tree/base/Tree.js';
+
+/**
+ * Split.
+ *
+ * @param {Tree} left
+ * @param {any} middle
+ * @param {Tree} right
+ */
 export function Split(left, middle, right) {
+	assert(left instanceof Tree);
+	assert(right instanceof Tree);
 	this._left = left;
 	this._middle = middle;
 	this._right = right;

src/0-core/_fast/index.js

@@ -1,16 +1,22 @@
-import {Deep} from '../../3-tree/index.js';
+import assert from 'assert';
+
+import {Digit} from '../../1-digit/0-Digit.js';
+import {Deep, Tree} from '../../3-tree/index.js';
 import {delay} from '../../4-lazy/index.js';
-import {_from_digit, _digit} from '../_fast/index.js';
 
 /**
- * @param {Measure} M
- * @param {Array} left
- * @param {FingerTree} middle
+ * @param {any} M
+ * @param {Digit|null} left
+ * @param {Tree} middle
  * @param {Digit} right
  */
 export function deepL(M, left, middle, right) {
-	if (left.length === 0) {
-		if (middle.isEmpty()) return _from_digit(M, right);
+	assert(left === null || left instanceof Digit);
+	assert(middle instanceof Tree);
+	assert(right instanceof Digit);
+
+	if (left === null) {
+		if (middle.isEmpty()) return right._tree(M);
 
 		return new Deep(
 			M,
@@ -20,5 +26,5 @@ export function deepL(M, left, middle, right) {
 		);
 	}
 
-	return new Deep(M, _digit(left), middle, right);
+	return new Deep(M, left, middle, right);
 }

src/0-core/split/DigitSplit.js

@@ -1,16 +1,22 @@
-import {Deep} from '../../3-tree/index.js';
+import assert from 'assert';
+
+import {Digit} from '../../1-digit/0-Digit.js';
+import {Deep, Tree} from '../../3-tree/index.js';
 import {delay} from '../../4-lazy/index.js';
-import {_from_digit, _digit} from '../_fast/index.js';
 
 /**
- * @param {Measure} M
+ * @param {any} M
  * @param {Digit} left
- * @param {FingerTree} middle
- * @param {Array} right
+ * @param {Tree} middle
+ * @param {Digit|null} right
  */
 export function deepR(M, left, middle, right) {
-	if (right.length === 0) {
-		if (middle.isEmpty()) return _from_digit(M, left);
+	assert(left instanceof Digit);
+	assert(middle instanceof Tree);
+	assert(right === null || right instanceof Digit);
+
+	if (right === null) {
+		if (middle.isEmpty()) return left._tree(M);
 
 		return new Deep(
 			M,
@@ -20,5 +26,5 @@ export function deepR(M, left, middle, right) {
 		);
 	}
 
-	return new Deep(M, left, middle, _digit(right));
+	return new Deep(M, left, middle, right);
 }

src/0-core/split/Split.js

@@ -1,6 +1,7 @@
 import assert from 'assert';
 import {node2, node3} from '../2-node/index.js';
-import {Split} from '../0-core/index.js';
+import {DigitSplit} from '../0-core/split/DigitSplit.js';
+import {Single} from '../3-tree/implementations/1-Single.js';
 import {Digit, Two, Three, Four} from './index.js';
 
 export function One(a) {
@@ -43,12 +44,16 @@ One.prototype._node = function (_M) {
 	throw new Error('cannot convert One to node');
 };
 
+One.prototype._tree = function (M) {
+	return new Single(M, this.a);
+};
+
 /**
  * It is assumed that p(i+|this|) is true.
  */
 One.prototype._splitDigit = function (p, i, M) {
 	assert(p(M.plus(i, this.measure(M)))); // /!\ Potential Heisenbug generator.
-	return new Split([], this.a, []);
+	return new DigitSplit(null, this.a, null);
 };
 
 One.prototype._nodes = function (M, other) {

src/0-core/split/deepL.js

@@ -1,6 +1,9 @@
 import assert from 'assert';
 import {Node2, node2, node3} from '../2-node/index.js';
-import {Split} from '../0-core/index.js';
+import {DigitSplit} from '../0-core/split/DigitSplit.js';
+import {Empty} from '../3-tree/implementations/0-Empty.js';
+import {cache} from '../0-core/measure/cache.js';
+import {Deep} from '../3-tree/implementations/2-Deep.js';
 import {Digit, One, Three, Four} from './index.js';
 
 export function Two(a, b) {
@@ -44,14 +47,18 @@ Two.prototype._node = function (M) {
 	return new Node2(this.measure(M), this.a, this.b);
 };
 
+Two.prototype._tree = function (M) {
+	return new Deep(M, new One(this.a), new Empty(cache(M)), new One(this.b));
+};
+
 /**
  * It is assumed that p(i+|this|) is true.
  */
 Two.prototype._splitDigit = function (p, i, M) {
 	assert(p(M.plus(i, this.measure(M)))); // /!\ Potential Heisenbug generator.
 	i = M.plus(i, M.measure(this.a));
-	if (p(i)) return new Split([], this.a, [this.b]);
-	return new Split([this.a], this.b, []);
+	if (p(i)) return new DigitSplit(null, this.a, new One(this.b));
+	return new DigitSplit(new One(this.a), this.b, null);
 };
 
 Two.prototype._nodes = function (M, other) {