functionalscript 0.43.1 → 0.44.0

package/fjs/types/btree/find/proof.f.mjs

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

package/fjs/types/btree/find/types.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Types for B-tree lookup results and paths.
+ *
+ * @module
+ */
+import type { Index } from '../../array/types.ts';
+import type { List } from '../../list/types.ts';
+import type { Branch3, Branch5, Leaf1, Leaf2 } from '../types/types.ts';
+type _FirstLeaf1<T> = readonly [Index<3>, Leaf1<T>];
+type _FirstBranch3<T> = readonly [1, Branch3<T>];
+type _FirstLeaf2<T> = readonly [Index<5>, Leaf2<T>];
+type _FirstBranch5<T> = readonly [1 | 3, Branch5<T>];
+export type First<T> = _FirstLeaf1<T> | _FirstBranch3<T> | _FirstLeaf2<T> | _FirstBranch5<T>;
+type _PathItem3<T> = readonly [0 | 2, Branch3<T>];
+type _PathItem5<T> = readonly [0 | 2 | 4, Branch5<T>];
+export type PathItem<T> = _PathItem3<T> | _PathItem5<T>;
+export type Path<T> = List<PathItem<T>>;
+export type Result<T> = {
+    readonly first: First<T>;
+    readonly tail: Path<T>;
+};
+export {};

package/fjs/types/btree/find/types.js

@@ -0,0 +1,6 @@
+/**
+ * Types for B-tree lookup results and paths.
+ *
+ * @module
+ */
+export {};

package/fjs/types/btree/module.f.d.mts

@@ -0,0 +1,10 @@
+/**
+ * Core persistent B-tree construction and traversal helpers.
+ *
+ * @module
+ */
+import type { List } from '../list/types.ts';
+import type { Tree } from './types/types.ts';
+export declare const empty: null;
+/** @type {<T>(tree: Tree<T>) => List<T>} */
+export declare const values: <T>(tree: Tree<T>) => List<T>;

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

@@ -0,0 +1,39 @@
+/**
+ * Core persistent B-tree construction and traversal helpers.
+ *
+ * @module
+ */
+
+import { flat } from '../list/module.f.mjs'
+/** @import { List, Thunk } from '../list/types.ts' */
+import { map } from '../nullable/module.f.mjs'
+/** @import { TNode, Tree } from './types/types.ts' */
+
+/** @type {<T>(node: TNode<T>) => 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<T>} */
+export const values = map(nodeValues)

package/fjs/types/btree/proof.f.d.mts

@@ -0,0 +1,14 @@
+/** @import { Unknown } from '../../media/json/types.ts' */
+declare const valueTest1: () => void;
+declare const valuesTest2: () => void;
+declare const findTrue: () => void;
+declare const find: () => void;
+declare const test: () => void;
+export declare const proof: {
+    valueTest1: typeof valueTest1;
+    valuesTest2: typeof valuesTest2;
+    findTrue: typeof findTrue;
+    find: typeof find;
+    test: typeof test;
+};
+export {};

package/fjs/types/btree/proof.f.mjs

@@ -0,0 +1,85 @@
+/** @import { Unknown } from '../../media/json/types.ts' */
+
+/** @import { TNode } from './types/types.ts' */
+import { values } from './module.f.mjs'
+import { stringify as jsonStringify } from '../../media/json/module.f.mjs'
+import { sort } from '../object/module.f.mjs'
+import { cmp } from '../string/module.f.mjs'
+/** @import { List, Result } from '../list/types.ts' */
+import { next, toArray } from '../list/module.f.mjs'
+import { set as setSet } from './set/module.f.mjs'
+import { value, find as findFind } from './find/module.f.mjs'
+import { assertEq } from '../../asserts/module.f.mjs'
+
+const jsonStr = jsonStringify(sort)
+
+/** @type {(sequence: List<Unknown>) => string} */
+const stringify = sequence => jsonStr(toArray(sequence))
+
+/** @type {(node: TNode<string>) => (value: string) => TNode<string>} */
+const set = node => value => setSet(cmp(value))(() => value)(node)
+
+const valueTest1 =() => {
+    /** @type {TNode<string>} */
+    let _map = ['a']
+    _map = set(_map)('b')
+    _map = set(_map)('c')
+    _map = set(_map)('d')
+    _map = set(_map)('e')
+    _map = set(_map)('f')
+    const result = stringify(values(_map))
+    assertEq(result, '["a","b","c","d","e","f"]')
+}
+
+const valuesTest2 = () => {
+    /** @type {TNode<string>} */
+    let _map = ['1']
+    for(let i = 2; i <= 10; i++)
+        _map = set(_map)((i*i).toString())
+    const result = stringify(values(_map))
+    assertEq(result, '["1","100","16","25","36","4","49","64","81","9"]')
+}
+
+const findTrue = () => {
+    /** @type {TNode<string>} */
+    let _map = ['a']
+    _map = set(_map)('b')
+    _map = set(_map)('c')
+    const result = value(findFind(cmp('b'))(_map).first)
+    assertEq(result, 'b')
+}
+
+const find = () => {
+    /** @type {TNode<string>} */
+    let _map = ['a']
+    _map = set(_map)('b')
+    _map = set(_map)('c')
+    const result = value(findFind(cmp('e'))(_map).first)
+    assertEq(result, null)
+}
+
+const test = () => {
+    /** @type {TNode<string>} */
+    let _map = ['a']
+    _map = set(_map)('b')
+    _map = set(_map)('c')
+    _map = set(_map)('d')
+    _map = set(_map)('e')
+    _map = set(_map)('f')
+    //
+    {
+        /** @type {Result<string>} */
+        let _item = next(values(_map))
+        while (_item !== null) {
+            _item = next(_item.tail)
+        }
+    }
+}
+
+export const proof = {
+    valueTest1,
+    valuesTest2,
+    findTrue,
+    find,
+    test,
+}

package/fjs/types/btree/remove/module.f.d.mts

@@ -0,0 +1,21 @@
+import type { Leaf1, TNode, Branch1, Branch3, Branch5, Tree } from '../types/types.ts';
+import type { Compare } from '../../function/compare/types.ts';
+import type { Path } from '../find/types.ts';
+export type _Leaf01<T> = null | Leaf1<T>;
+export type _RemovePath<T> = {
+    readonly first: _Leaf01<T>;
+    readonly tail: Path<T>;
+};
+export type _Branch<T> = Branch1<T> | Branch3<T> | Branch5<T>;
+export type _Merge<A, T> = (a: A) => (n: Branch3<T>) => Branch1<T> | Branch3<T>;
+/** @type {<T>(c: Compare<T>) => (node: TNode<T>) => Tree<T>} */
+export declare const nodeRemove: <T>(c: Compare<T>) => (node: TNode<T>) => Tree<T>;
+/** @type {<T>(c: Compare<T>) => (tree: Tree<T>) => Tree<T>} */
+export declare const remove: <T>(c: Compare<T>) => (tree: Tree<T>) => Tree<T>;
+export declare const proof: {
+    throw: {
+        reduceValue0DefaultBranch: () => void;
+        reduceValue2DefaultBranch: () => void;
+        initValue1DefaultBranch: () => void;
+    };
+};

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

@@ -0,0 +1,187 @@
+/**
+ * Removal operations for persistent B-tree structures.
+ *
+ * @module
+ */
+import { collapseRoot } from '../types/module.f.mjs'
+/** @import { Leaf1, TNode, Branch1, Branch3, Branch5, Tree } from '../types/types.ts' */
+
+/** @import { Compare } from '../../function/compare/types.ts' */
+
+import { find } from '../find/module.f.mjs'
+/** @import { Path, PathItem } from '../find/types.ts' */
+
+import { fold, concat, next } from '../../list/module.f.mjs'
+
+/** @import { Tuple } from '../../array/types.ts' */
+
+import { map } from '../../nullable/module.f.mjs'
+
+/**
+ * @template T
+ * @typedef {null | Leaf1<T>} _Leaf01
+ */
+
+/**
+ * @template T
+ * @typedef {{
+ *   readonly first: _Leaf01<T>,
+ *   readonly tail: Path<T>
+ * }} _RemovePath
+ */
+
+/** @type {<T>(tail: Path<T>) => (n: TNode<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
+ * @template T
+ * @typedef {(a: A) => (n: Branch3<T>) => Branch1<T> | Branch3<T>} _Merge
+ */
+
+/** @type {<A, T>(ms: Tuple<2, _Merge<A, T>>) => (item: PathItem<T>) => (a: A) => _Branch<T>} */
+const reduceX = ms => ([i, n]) => a => {
+    /** @typedef {(typeof n)[1]} T */
+    const [m0, m2] = ms
+    /** @type {(m: typeof m0) => _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: Compare<T>) => (node: TNode<T>) => Tree<T>} */
+export const nodeRemove = c => node => {
+    /** @typedef {typeof c extends Compare<infer T> ? T : never} T */
+    /** @type {() => null | _RemovePath<T>} */
+    const f = () => {
+        const { first, tail } = find(c)(node)
+        /** @type {(n: TNode<T>) => (f: (v: T) => PathItem<T>) => _RemovePath<T>} */
+        const branch = n => f => {
+            const [v, p] = path(/** @type {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
+    return collapseRoot(reduce(initReduce(tf)(first))(tt))
+}
+
+/** @type {<T>(c: Compare<T>) => (tree: Tree<T>) => Tree<T>} */
+export const remove = c => map(nodeRemove(c))
+
+// `reduceValue0`/`reduceValue2`/`initValue0`/`initValue1` merge a Branch1's lone
+// child into its Branch3 sibling. The sibling is always a Branch (length 3 or 5)
+// in every reachable tree shape, so the `default` arm guarding a mismatched
+// (leaf) sibling length can't be hit through the public `remove` API. Exercise
+// it directly here so the invariant guard itself stays covered.
+export const proof = {
+    throw: {
+        reduceValue0DefaultBranch: () => {
+            reduceValue0([['leaf']])([['x'], 's', ['y']])
+        },
+        reduceValue2DefaultBranch: () => {
+            reduceValue2([['leaf']])([['x'], 's', ['y']])
+        },
+        initValue1DefaultBranch: () => {
+            initValue1(null)([[['a'], 'b', ['c']], 'd', ['e']])
+        },
+    },
+}