functionalscript 0.43.1 → 0.45.0

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

@@ -1,108 +0,0 @@
-import { find as btreeFind } from './module.f.js';
-import { map, toArray } from '../../list/module.f.js';
-import { stringify } from '../../../media/json/module.f.js';
-import { sort } from '../../object/module.f.js';
-import {} from '../types/module.f.js';
-import { cmp } from '../../string/module.f.js';
-import { set as setSet } from '../set/module.f.js';
-import { assertEq } from '../../../asserts/module.f.js';
-const jsonStr = stringify(sort);
-const set = node => value => setSet(cmp(value))(() => value)(node);
-const str = r => jsonStr(toArray(map((x) => x[0])(r)));
-const find = i => m => str(btreeFind(cmp(i))(m));
-const test = () => {
-    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/module.f.d.ts

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

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

@@ -1,33 +0,0 @@
-/**
- * Core persistent B-tree construction and traversal helpers.
- *
- * @module
- */
-import { flat } from '../list/module.f.js';
-import { map } from '../nullable/module.f.js';
-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;
-export const values = map(nodeValues);

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

@@ -1,13 +0,0 @@
-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.js

@@ -1,64 +0,0 @@
-import { values } from './module.f.js';
-import { stringify as jsonStringify } from '../../media/json/module.f.js';
-import { sort } from '../object/module.f.js';
-import { cmp } from '../string/module.f.js';
-import { next, toArray } from '../list/module.f.js';
-import { set as setSet } from './set/module.f.js';
-import { value, find as findFind } from './find/module.f.js';
-import { assertEq } from '../../asserts/module.f.js';
-const jsonStr = jsonStringify(sort);
-const stringify = sequence => jsonStr(toArray(sequence));
-const set = node => value => setSet(cmp(value))(() => value)(node);
-const valueTest1 = () => {
-    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 = () => {
-    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 = () => {
-    let _map = ['a'];
-    _map = set(_map)('b');
-    _map = set(_map)('c');
-    const result = value(findFind(cmp('b'))(_map).first);
-    assertEq(result, 'b');
-};
-const find = () => {
-    let _map = ['a'];
-    _map = set(_map)('b');
-    _map = set(_map)('c');
-    const result = value(findFind(cmp('e'))(_map).first);
-    assertEq(result, null);
-};
-const test = () => {
-    let _map = ['a'];
-    _map = set(_map)('b');
-    _map = set(_map)('c');
-    _map = set(_map)('d');
-    _map = set(_map)('e');
-    _map = set(_map)('f');
-    //
-    {
-        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.ts

@@ -1,14 +0,0 @@
-/**
- * Removal operations for persistent B-tree structures.
- *
- * @module
- */
-import { type TNode, type Tree } from '../types/module.f.ts';
-import type { Compare } from '../../function/compare/module.f.ts';
-export declare const nodeRemove: <T>(c: Compare<T>) => (node: TNode<T>) => Tree<T>;
-export declare const remove: <T>(c: Compare<T>) => (tree: Tree<T>) => Tree<T>;
-export declare const proof: {
-    throw: {
-        reduceValue0DefaultBranch: () => void;
-    };
-};

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

@@ -1,186 +0,0 @@
-/**
- * Removal operations for persistent B-tree structures.
- *
- * @module
- */
-import { collapseRoot } from '../types/module.f.js';
-import { find } from '../find/module.f.js';
-import { fold, concat, next } from '../../list/module.f.js';
-import { map } from '../../nullable/module.f.js';
-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]);
-        }
-    }
-};
-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];
-    }
-};
-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];
-    }
-};
-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];
-    }
-};
-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];
-    }
-};
-const reduceX = (ms) => ([i, n]) => (a) => {
-    const [m0, m2] = ms;
-    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]);
-export const nodeRemove = (c) => (node) => {
-    const f = () => {
-        const { first, tail } = find(c)(node);
-        const branch = n => f => {
-            const [v, p] = path(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));
-};
-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']]);
-        },
-    },
-};

package/fjs/types/btree/remove/proof.f.d.ts

@@ -1,9 +0,0 @@
-declare const test: () => void;
-declare const test2: () => void;
-declare const test3: () => void;
-export declare const proof: {
-    test: typeof test;
-    test2: typeof test2;
-    test3: typeof test3;
-};
-export {};