functionalscript 0.2.0 → 0.2.2

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

@@ -0,0 +1,137 @@
+// @ts-self-types="./module.f.d.mts"
+import * as _ from '../types/module.f.mjs';
+import * as List from '../../list/module.f.mjs';
+import * as cmp from '../../function/compare/module.f.mjs';
+const { index3, index5 } = cmp;
+import * as Array from '../../array/module.f.mjs';
+/**
+ * @template T
+ * @typedef {readonly[cmp.Index3, _.Leaf1<T>]} FirstLeaf1
+ */
+/**
+ * @template T
+ * @typedef {readonly[1, _.Branch3<T>]} FirstBranch3
+ */
+/**
+ * @template T
+ * @typedef {readonly[cmp.Index5, _.Leaf2<T>]} FirstLeaf2
+ */
+/**
+ * @template T
+ * @typedef {readonly[1|3, _.Branch5<T>]} FirstBranch5
+ */
+/**
+ * @template T
+ * @typedef {FirstLeaf1<T> | FirstBranch3<T> | FirstLeaf2<T> | FirstBranch5<T>} First
+ */
+/**
+ * @template T
+ * @typedef {readonly[0|2, _.Branch3<T>]} PathItem3
+ */
+/**
+ * @template T
+ * @typedef {readonly[0|2|4, _.Branch5<T>]} PathItem5
+ */
+/**
+ * @template T
+ * @typedef {PathItem3<T> | PathItem5<T>} PathItem
+ */
+/** @type {<T>(item: PathItem<T>) => _.Node<T>} */
+const child = item => 
+/** @type {typeof item extends PathItem<infer T> ? _.Node<T> : never} */ (item[1][item[0]]);
+/**
+ * @template T
+ * @typedef {List.List<PathItem<T>>} Path
+ */
+/**
+ * @template T
+ * @typedef {{
+ *  readonly first: First<T>,
+ *  readonly tail: Path<T>
+ * }} Result<T>
+ */
+/** @type {<T>(c: cmp.Compare<T>) => (node: _.Node<T>) => Result<T>} */
+export const find = c => {
+    const i3 = index3(c);
+    const i5 = index5(c);
+    /** @typedef {typeof c extends cmp.Compare<infer T> ? T : never} T */
+    /** @type {(prior: Path<T>) => (node: _.Node<T>) => Result<T>} */
+    const f = tail => node => {
+        /** @type {(index: Array.KeyOf<typeof node>) => Result<T>} */
+        const append = index => {
+            const first = /** @type {PathItem<T>} */ ([index, node]);
+            return f({ first, tail })(child(first));
+        };
+        /** @type {(index: Array.KeyOf<typeof node>) => Result<T>} */
+        const done = index => ({ first: /** @type {First<T>} */ ([index, node]), tail });
+        switch (node.length) {
+            case 1: {
+                return done(i3(node[0]));
+            }
+            case 2: {
+                return done(i5(node));
+            }
+            case 3: {
+                const i = i3(node[1]);
+                switch (i) {
+                    case 0:
+                    case 2: {
+                        return append(i);
+                    }
+                    case 1: {
+                        return done(i);
+                    }
+                }
+            }
+            case 5: {
+                const i = i5([node[1], node[3]]);
+                switch (i) {
+                    case 0:
+                    case 2:
+                    case 4: {
+                        return append(i);
+                    }
+                    case 1:
+                    case 3: {
+                        return done(i);
+                    }
+                }
+            }
+        }
+    };
+    return f(null);
+};
+/** @type {<T>(first: First<T>) => boolean} */
+export const isFound = ([i]) => {
+    switch (i) {
+        case 1:
+        case 3: {
+            return true;
+        }
+        default: {
+            return false;
+        }
+    }
+};
+/** @type {<T>(first: First<T>) => T | null} */
+export const value = ([i, r]) => {
+    switch (i) {
+        case 1: {
+            switch (r.length) {
+                case 1:
+                case 2: {
+                    return r[0];
+                }
+                default: {
+                    return r[1];
+                }
+            }
+        }
+        case 3: {
+            return r.length === 2 ? r[1] : r[3];
+        }
+        default: {
+            return null;
+        }
+    }
+};

package/out/types/btree/find/test.f.mjs

@@ -0,0 +1,156 @@
+import * as _ from './module.f.mjs';
+import * as list from '../../list/module.f.mjs';
+import * as json from '../../../json/module.f.mjs';
+import * as o from '../../object/module.f.mjs';
+const { sort } = o;
+import * as btree from '../types/module.f.mjs';
+import * as string from '../../string/module.f.mjs';
+const { cmp } = string;
+import * as s from '../set/module.f.mjs';
+const jsonStr = json.stringify(sort);
+/** @type {(node: btree.Node<string>) => (value: string) => btree.Node<string>} */
+const set = node => value => s.set(cmp(value))(() => value)(node);
+/** @type {(r: _.Result<json.Unknown>) => string} */
+const str = r => jsonStr(list.toArray(list.map(x => x[0])(r)));
+/** @type {(i: string) => (m: btree.Node<string>) => string} */
+const find = i => m => str(_.find(cmp(i))(m));
+const test = () => {
+    /** @type {btree.Node<string>} */
+    let _map = ['1'];
+    for (let i = 2; i <= 10; i++)
+        _map = set(_map)((i * i).toString());
+    {
+        const s = jsonStr(_map);
+        if (s !== '[[["1","100"],"16",["25","36"]],"4",[["49"],"64",["81","9"]]]') {
+            throw s;
+        }
+    }
+    //
+    {
+        const r = find("0")(_map);
+        if (r !== '[0,0,0]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("1")(_map);
+        if (r !== '[1,0,0]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("10")(_map);
+        if (r !== '[2,0,0]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("100")(_map);
+        if (r !== '[3,0,0]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("12")(_map);
+        if (r !== '[4,0,0]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("16")(_map);
+        if (r !== '[1,0]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("17")(_map);
+        if (r !== '[0,2,0]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("25")(_map);
+        if (r !== '[1,2,0]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("26")(_map);
+        if (r !== '[2,2,0]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("36")(_map);
+        if (r !== '[3,2,0]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("37")(_map);
+        if (r !== '[4,2,0]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("4")(_map);
+        if (r !== '[1]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("41")(_map);
+        if (r !== '[0,0,2]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("49")(_map);
+        if (r !== '[1,0,2]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("5")(_map);
+        if (r !== '[2,0,2]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("64")(_map);
+        if (r !== '[1,2]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("65")(_map);
+        if (r !== '[0,2,2]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("81")(_map);
+        if (r !== '[1,2,2]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("85")(_map);
+        if (r !== '[2,2,2]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("9")(_map);
+        if (r !== '[3,2,2]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("91")(_map);
+        if (r !== '[4,2,2]') {
+            throw r;
+        }
+    }
+};
+export default test;

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

@@ -0,0 +1,34 @@
+// @ts-self-types="./module.f.d.mts"
+import * as list from '../list/module.f.mjs';
+const { flat } = list;
+import * as n from '../nullable/module.f.mjs';
+const { map } = n;
+import * as _ from './types/module.f.mjs';
+/** @type {<T>(node: _.Node<T>) => list.Thunk<T>} */
+const nodeValues = node => () => {
+    switch (node.length) {
+        case 1:
+        case 2: {
+            return node;
+        }
+        case 3: {
+            return flat([
+                nodeValues(node[0]),
+                [node[1]],
+                nodeValues(node[2])
+            ]);
+        }
+        default: {
+            return flat([
+                nodeValues(node[0]),
+                [node[1]],
+                nodeValues(node[2]),
+                [node[3]],
+                nodeValues(node[4])
+            ]);
+        }
+    }
+};
+export const empty = null;
+/** @type {<T>(tree: _.Tree<T>) => list.List<T>} */
+export const values = map(nodeValues);

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));