functionalscript 0.1.609 → 0.2.1

package/out/types/btree/remove/module.f.mjs

@@ -0,0 +1,209 @@
+// @ts-self-types="./module.f.d.mts"
+import * as _ from '../types/module.f.mjs';
+import * as Cmp from '../../function/compare/module.f.mjs';
+import * as find from '../find/module.f.mjs';
+import * as list from '../../list/module.f.mjs';
+const { fold, concat, next } = list;
+import * as Array from '../../array/module.f.mjs';
+import * as n from '../../nullable/module.f.mjs';
+const { map } = n;
+/**
+ * @template T
+ * @typedef {null | _.Leaf1<T>} Leaf01
+ */
+/**
+ * @template T
+ * @typedef {{
+ *  readonly first: Leaf01<T>,
+ *  readonly tail: find.Path<T>
+ * }} RemovePath
+ */
+/** @type {<T>(tail: find.Path<T>) => (n: _.Node<T>) => readonly[T, RemovePath<T>]} */
+const path = tail => n => {
+    switch (n.length) {
+        case 1: {
+            return [n[0], { first: null, tail }];
+        }
+        case 2: {
+            return [n[0], { first: [n[1]], tail }];
+        }
+        case 3: {
+            return path({ first: [0, n], tail })(n[0]);
+        }
+        case 5: {
+            return path({ first: [0, n], tail })(n[0]);
+        }
+    }
+};
+/**
+ * @template T
+ * @typedef {_.Branch1<T> | _.Branch3<T> | _.Branch5<T>} Branch
+ */
+/** @type {<T>(a: Branch<T>) => (n: _.Branch3<T>) => _.Branch1<T> | _.Branch3<T>} */
+const reduceValue0 = a => n => {
+    const [, v1, n2] = n;
+    if (a.length === 1) {
+        switch (n2.length) {
+            case 3: {
+                return [[a[0], v1, ...n2]];
+            }
+            case 5: {
+                return [[a[0], v1, n2[0]], n2[1], [n2[2], n2[3], n2[4]]];
+            }
+            default: {
+                throw 'invalid node';
+            }
+        }
+    }
+    else {
+        return [a, v1, n2];
+    }
+};
+/** @type {<T>(a: Branch<T>) => (n: _.Branch3<T>) => _.Branch1<T> | _.Branch3<T>} */
+const reduceValue2 = a => n => {
+    const [n0, v1,] = n;
+    if (a.length === 1) {
+        switch (n0.length) {
+            case 3: {
+                return [[...n0, v1, a[0]]];
+            }
+            case 5: {
+                return [[n0[0], n0[1], n0[2]], n0[3], [n0[4], v1, a[0]]];
+            }
+            default: {
+                throw 'invalid node';
+            }
+        }
+    }
+    else {
+        return [n0, v1, a];
+    }
+};
+/** @type {<T>(a: Leaf01<T>) => (n: _.Branch3<T>) => _.Branch1<T> | _.Branch3<T>} */
+const initValue0 = a => n => {
+    const [, v1, n2] = n;
+    if (a === null) {
+        switch (n2.length) {
+            case 1: {
+                return [[v1, ...n2]];
+            }
+            case 2: {
+                return [[v1], n2[0], [n2[1]]];
+            }
+            default: {
+                throw 'invalid node';
+            }
+        }
+    }
+    else {
+        return [a, v1, n2];
+    }
+};
+/** @type {<T>(a: Leaf01<T>) => (n: _.Branch3<T>) => _.Branch1<T> | _.Branch3<T>} */
+const initValue1 = a => n => {
+    const [n0, v1] = n;
+    if (a === null) {
+        switch (n0.length) {
+            case 1: {
+                return [[...n0, v1]];
+            }
+            case 2: {
+                return [[n0[0]], n0[1], [v1]];
+            }
+            default: {
+                throw 'invalid node';
+            }
+        }
+    }
+    else {
+        return [n0, v1, a];
+    }
+};
+/**
+ * @template A,T
+ * @typedef {(a: A) => (n: _.Branch3<T>) => _.Branch1<T> | _.Branch3<T>} Merge
+ */
+/** @type {<A, T>(ms: Array.Array2<Merge<A, T>>) => (i: find.PathItem<T>) => (a: A) => Branch<T>} */
+const reduceX = ms => ([i, n]) => a => {
+    const [m0, m2] = ms;
+    /** @typedef {typeof ms extends Array.Array2<Merge<infer A, infer T>> ? [A,T] : never} AT */
+    /** @typedef {AT[0]} A */
+    /** @typedef {AT[1]} T */
+    /** @type {(m: Merge<A, T>) => Branch<T>} */
+    const f = m => {
+        const ra = m(a);
+        return n.length === 3 ? ra(n) : [...ra([n[0], n[1], n[2]]), n[3], n[4]];
+    };
+    switch (i) {
+        case 0: {
+            return f(m0);
+        }
+        case 2: {
+            return f(m2);
+        }
+        case 4: {
+            return [n[0], n[1], ...m2(a)([n[2], n[3], n[4]])];
+        }
+    }
+};
+const reduce = fold(reduceX([reduceValue0, reduceValue2]));
+const initReduce = reduceX([initValue0, initValue1]);
+/** @type {<T>(c: Cmp.Compare<T>) => (node: _.Node<T>) => _.Tree<T>} */
+export const nodeRemove = c => node => {
+    /** @typedef {typeof c extends Cmp.Compare<infer T> ? T : never} T */
+    /** @type  {() => null | RemovePath<T>} */
+    const f = () => {
+        const { first, tail } = find.find(c)(node);
+        /** @type {(n: _.Node<T>) => (f: (v: T) => find.PathItem<T>) => RemovePath<T>} */
+        const branch = n => f => {
+            const [v, p] = path(/** @type {find.Path<T>} */ (null))(n);
+            return { first: p.first, tail: concat(p.tail)({ first: f(v), tail }) };
+        };
+        const [i, n] = first;
+        switch (i) {
+            case 1: {
+                switch (n.length) {
+                    case 1: {
+                        return { first: null, tail };
+                    }
+                    case 2: {
+                        return { first: [n[1]], tail };
+                    }
+                    case 3: {
+                        return branch(n[2])(v => [2, [n[0], v, n[2]]]);
+                    }
+                    case 5: {
+                        return branch(n[2])(v => [2, [n[0], v, n[2], n[3], n[4]]]);
+                    }
+                }
+            }
+            case 3: {
+                switch (n.length) {
+                    case 2: {
+                        return { first: [n[0]], tail };
+                    }
+                    case 5: {
+                        return branch(n[4])(v => [4, [n[0], n[1], n[2], v, n[4]]]);
+                    }
+                }
+            }
+            default: {
+                return null;
+            }
+        }
+    };
+    const r = f();
+    if (r === null) {
+        return node;
+    }
+    const { first, tail } = r;
+    const tailR = next(tail);
+    if (tailR === null) {
+        return first;
+    }
+    const { first: tf, tail: tt } = tailR;
+    const result = reduce(initReduce(tf)(first))(tt);
+    return result.length === 1 ? result[0] : result;
+};
+/** @type {<T>(c: Cmp.Compare<T>) => (tree: _.Tree<T>) => _.Tree<T>} */
+export const remove = c => map(nodeRemove(c));