functionalscript 0.43.1 → 0.45.0

package/fjs/types/rtti/validate/proof.f.js

@@ -1,349 +0,0 @@
-import { validate } from './module.f.js';
-import { boolean, number, string, bigint, unknown, array, record, or, option } from '../module.f.js';
-import { assert, assertEq } from '../../../asserts/module.f.js';
-const assertOk = ([k]) => { assertEq(k, 'ok', 'expected ok'); };
-const assertError = ([k]) => { assertEq(k, 'error', 'expected error'); };
-const assertErrorPath = (expected) => (r) => {
-    assert(r[0] === 'error', 'expected error');
-    const e = r[1];
-    if (e.path.length !== expected.length) {
-        throw `path length ${e.path.length} != ${expected.length}`;
-    }
-    for (let i = 0; i < expected.length; i++) {
-        if (e.path[i] !== expected[i]) {
-            throw `path[${i}] ${e.path[i]} != ${expected[i]}`;
-        }
-    }
-};
-export const proof = {
-    boolean: {
-        ok: () => {
-            assertOk(validate(boolean)(true));
-            assertOk(validate(boolean)(false));
-        },
-        error: () => {
-            assertError(validate(boolean)(0));
-            assertError(validate(boolean)('true'));
-            assertError(validate(boolean)(null));
-        },
-    },
-    number: {
-        ok: () => {
-            assertOk(validate(number)(42));
-        },
-        error: () => {
-            assertError(validate(number)('42'));
-            assertError(validate(number)(42n));
-        },
-    },
-    string: {
-        ok: () => {
-            assertOk(validate(string)('hello'));
-        },
-        error: () => {
-            assertError(validate(string)(42));
-            assertError(validate(string)(null));
-        },
-    },
-    bigint: {
-        ok: () => {
-            assertOk(validate(bigint)(4n));
-        },
-        error: () => {
-            assertError(validate(bigint)(4));
-            assertError(validate(bigint)('4'));
-        },
-    },
-    unknown: {
-        ok: () => {
-            assertOk(validate(unknown)(null));
-            assertOk(validate(unknown)(42));
-            assertOk(validate(unknown)('hello'));
-            assertOk(validate(unknown)(true));
-            assertOk(validate(unknown)({}));
-            assertOk(validate(unknown)([]));
-        },
-    },
-    const: {
-        null: {
-            ok: () => {
-                assertOk(validate(null)(null));
-            },
-            error: () => {
-                assertError(validate(null)(undefined));
-                assertError(validate(null)(0));
-            },
-        },
-        undefined: {
-            ok: () => {
-                assertOk(validate(undefined)(undefined));
-            },
-            error: () => assertError(validate(undefined)(null)),
-        },
-        number: {
-            ok: () => {
-                assertOk(validate(42)(42));
-            },
-            error: () => assertError(validate(42)(43)),
-        },
-        nan: {
-            ok: () => assertOk(validate(NaN)(NaN)),
-            error: () => {
-                assertError(validate(NaN)(0));
-                assertError(validate(0)(NaN));
-                assertError(validate(42)(NaN));
-            },
-        },
-        infinity: {
-            ok: () => {
-                assertOk(validate(Infinity)(Infinity));
-                assertOk(validate(-Infinity)(-Infinity));
-            },
-            error: () => {
-                assertError(validate(Infinity)(-Infinity));
-                assertError(validate(Infinity)(0));
-            },
-        },
-        signedZero: {
-            // `Object.is` distinguishes +0 and -0; `===` treats them equal.
-            distinct: () => {
-                assertError(validate(0)(-0));
-                assertError(validate(-0)(0));
-            },
-            self: () => {
-                assertOk(validate(0)(0));
-                assertOk(validate(-0)(-0));
-            },
-        },
-        string: {
-            ok: () => {
-                assertOk(validate('hello')('hello'));
-            },
-            error: () => assertError(validate('hello')('world')),
-        },
-        bigint: {
-            ok: () => {
-                assertOk(validate(7n)(7n));
-            },
-            error: () => assertError(validate(7n)(8n)),
-        },
-        boolean: {
-            ok: () => {
-                assertOk(validate(true)(true));
-            },
-            error: () => assertError(validate(true)(false)),
-        },
-        tuple: {
-            ok: () => {
-                const t = [42, 'hello'];
-                assertOk(validate(t)([42, 'hello']));
-            },
-            extraItems: () => assertOk(validate([42])([42, 'extra'])),
-            error: () => {
-                assertError(validate([42])([99]));
-                assertError(validate([42])({}));
-            },
-        },
-        struct: {
-            ok: () => {
-                const t = { a: 42, b: 'hello' };
-                assertOk(validate(t)({ a: 42, b: 'hello' }));
-            },
-            extraKeys: () => assertOk(validate({ a: 42 })({ a: 42, b: 'extra' })),
-            error: () => {
-                assertError(validate({ a: 42 })({ a: 99 }));
-                assertError(validate({ a: 42 })([]));
-            },
-        },
-    },
-    array: {
-        empty: () => assertOk(validate(array(number))([])),
-        ok: () => {
-            const t = array(number);
-            assertOk(validate(array(number))([1, 2, 3]));
-        },
-        error: () => {
-            assertError(validate(array(number))([1, 'two', 3]));
-            assertError(validate(array(number))({}));
-            assertError(validate(array(number))(null));
-        },
-        nested: () => {
-            const t = array(array(boolean));
-            assertOk(validate(array(array(boolean)))([[true, false], [false]]));
-            assertError(validate(array(array(boolean)))([[true, 42]]));
-        },
-    },
-    record: {
-        empty: () => assertOk(validate(record(number))({})),
-        ok: () => {
-            const t = record(string);
-            assertOk(validate(t)({ a: 'hello', b: 'world' }));
-        },
-        error: () => {
-            assertError(validate(record(number))({ a: 1, b: 'two' }));
-            assertError(validate(record(number))(null));
-            assertError(validate(record(number))([]));
-        },
-    },
-    constThunk: {
-        primitive: () => {
-            const t = () => ['const', 7n];
-            assertOk(validate(t)(7n));
-            assertError(validate(t)(8n));
-        },
-    },
-    or: {
-        consts: {
-            ok: () => {
-                const t = or(...[false, 42, 'hello']);
-                assertOk(validate(t)(false));
-                assertOk(validate(t)(42));
-                assertOk(validate(t)('hello'));
-            },
-            error: () => {
-                const t = or(...[false, 42, 'hello']);
-                assertError(validate(t)(true));
-                assertError(validate(t)(43));
-                assertError(validate(t)('world'));
-                assertError(validate(t)(null));
-            },
-        },
-        thunks: {
-            ok: () => {
-                const t = or(number, string);
-                assertOk(validate(t)(42));
-                assertOk(validate(t)('hello'));
-            },
-            error: () => {
-                const t = or(number, string);
-                assertError(validate(t)(true));
-                assertError(validate(t)(null));
-            },
-        },
-        mixed: {
-            ok: () => {
-                const t = or(42, string);
-                assertOk(validate(t)(42));
-                assertOk(validate(t)('hello'));
-            },
-            error: () => {
-                const t = or(42, string);
-                assertError(validate(t)(43));
-                assertError(validate(t)(null));
-            },
-        },
-    },
-    option: {
-        ok: () => {
-            const t = option(number);
-            assertOk(validate(t)(42));
-            assertOk(validate(t)(undefined));
-        },
-        error: () => {
-            const t = option(number);
-            assertError(validate(t)(null));
-            assertError(validate(t)('42'));
-        },
-    },
-    path: {
-        rootMismatch: () => assertErrorPath([])(validate(number)('not a number')),
-        arrayIndex: () => assertErrorPath(['1'])(validate(array(number))([1, 'two', 3])),
-        recordKey: () => {
-            const r = validate(record(number))({ a: 1, b: 'two', c: 3 });
-            // record iteration order matches Object.entries; 'b' is the failing key
-            assertErrorPath(['b'])(r);
-        },
-        nestedArray: () => assertErrorPath(['0', '1'])(validate(array(array(number)))([[1, 'x'], [2, 3]])),
-        tupleIndex: () => assertErrorPath(['1'])(validate([number, number])([1, 'two'])),
-        structKey: () => assertErrorPath(['b'])(validate({ a: number, b: number })({ a: 1, b: 'two' })),
-        deepStruct: () => {
-            const schema = { user: { name: string, age: number } };
-            const r = validate(schema)({ user: { name: 'A', age: 'old' } });
-            assertErrorPath(['user', 'age'])(r);
-        },
-        recursiveSchema: () => {
-            const list = () => ['array', list];
-            // [[[42]]] — innermost element 42 is a number, not an array
-            const r = validate(list)([[[42]]]);
-            assertErrorPath(['0', '0', '0'])(r);
-        },
-        orRoot: () => assertErrorPath([])(validate(or(number, string))(true)),
-    },
-    recursive: {
-        arrayOfArrays: () => {
-            // self-referential schema: an array whose elements are also arrays of the same type
-            const list = () => ['array', list];
-            const v = validate(list);
-            assertOk(v([]));
-            assertOk(v([[], []]));
-            assertOk(v([[[], []], []]));
-            assertError(v([42]));
-            assertError(v(null));
-        },
-        recordOfRecords: () => {
-            const tree = () => ['record', tree];
-            const v = validate(tree);
-            assertOk(v({}));
-            assertOk(v({ a: {}, b: { c: {} } }));
-            assertError(v({ a: 42 }));
-        },
-    },
-    funcParam: () => {
-        const paramSet0 = ['hello', bigint];
-        const paramSet1 = ['goodbye', string, 43];
-        const paramSet01 = or(paramSet0, paramSet1);
-        const v0 = validate(paramSet0);
-        const v1 = validate(paramSet1);
-        const func = (f0, f1) => (...args) => {
-            {
-                const [t, r] = v0(args);
-                if (t === 'ok') {
-                    return f0(...r);
-                }
-            }
-            {
-                const [t, r] = v1(args);
-                if (t === 'ok') {
-                    return f1(...r);
-                }
-            }
-            throw 'unreachable: args did not match any parameter set';
-        };
-        const f0 = (a, b) => 42;
-        const f1 = (a, b, c) => 13;
-        const x = func(f0, f1);
-        return () => {
-            assertEq(x('hello', 42n), 42);
-            assertEq(x('goodbye', 'world', 43), 13);
-        };
-    },
-    funcObj: () => {
-        const param0 = { a: 'hello', b: bigint };
-        const param1 = { a: 'goodbye', b: string, c: 43 };
-        const param01 = or(param0, param1);
-        const v0 = validate(param0);
-        const v1 = validate(param1);
-        const func = (f0, f1) => (args) => {
-            {
-                const [t, r] = v0(args);
-                if (t === 'ok') {
-                    return f0(r);
-                }
-            }
-            {
-                const [t, r] = v1(args);
-                if (t === 'ok') {
-                    return f1(r);
-                }
-            }
-            throw 'unreachable: args did not match any parameter set';
-        };
-        const f0 = (args) => Number(args.b) + args.a.length;
-        const f1 = (args) => args.c;
-        const x = func(f0, f1);
-        return () => {
-            assertEq(x({ a: 'hello', b: 42n }), 47);
-            assertEq(x({ a: 'goodbye', b: 'world', c: 43 }), 43);
-        };
-    }
-};

package/fjs/types/sorted_list/module.f.d.ts

@@ -1,26 +0,0 @@
-/**
- * Sorted immutable list helpers and merge operations.
- *
- * @module
- */
-import { type Sign, type Cmp } from '../function/compare/module.f.ts';
-import { type List } from '../list/module.f.ts';
-import type { Nullable } from '../nullable/module.f.ts';
-export type SortedList<T> = List<T>;
-type SortedArray<T> = readonly T[];
-export type ReduceOp<T, S> = (state: S) => (a: T) => (b: T) => readonly [Nullable<T>, Sign, S];
-export type TailReduce<T, S> = (state: S) => (tail: List<T>) => List<T>;
-type MergeReduce<T, S> = {
-    readonly reduceOp: ReduceOp<T, S>;
-    readonly tailReduce: TailReduce<T, S>;
-};
-/**
- * Two-way sorted-list merge.
- * `reduceOp` returns `[output, sign, nextState]` where sign `-1` advances `a`, `1` advances `b`, `0` advances both; `null` output skips emission.
- * `tailReduce` drains the non-exhausted list with current state once the other ends.
- */
-export declare const genericMerge: <T, S>({ reduceOp, tailReduce }: MergeReduce<T, S>) => (state: S) => (a: List<T>) => (b: List<T>) => List<T>;
-export declare const merge: <T>(cmp: Cmp<T>) => (a: SortedList<T>) => (b: SortedList<T>) => SortedList<T>;
-export declare const intersect: <T>(cmp: Cmp<T>) => (a: SortedList<T>) => (b: SortedList<T>) => SortedList<T>;
-export declare const find: <T>(cmp: Cmp<T>) => (value: T) => (array: SortedArray<T>) => T | null;
-export {};

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

@@ -1,51 +0,0 @@
-/**
- * Sorted immutable list helpers and merge operations.
- *
- * @module
- */
-import { bsearch } from '../function/compare/module.f.js';
-import { next } from '../list/module.f.js';
-import { identity } from '../function/module.f.js';
-/**
- * Two-way sorted-list merge.
- * `reduceOp` returns `[output, sign, nextState]` where sign `-1` advances `a`, `1` advances `b`, `0` advances both; `null` output skips emission.
- * `tailReduce` drains the non-exhausted list with current state once the other ends.
- */
-export const genericMerge = ({ reduceOp, tailReduce }) => {
-    const f = (state) => (a) => (b) => () => {
-        const aResult = next(a);
-        if (aResult === null) {
-            return tailReduce(state)(b);
-        }
-        const bResult = next(b);
-        if (bResult === null) {
-            return tailReduce(state)(aResult);
-        }
-        const [first, sign, stateNext] = reduceOp(state)(aResult.first)(bResult.first);
-        const aNext = sign === 1 ? a : aResult.tail;
-        const bNext = sign === -1 ? b : bResult.tail;
-        const tail = f(stateNext)(aNext)(bNext);
-        return first === null ? tail : { first, tail };
-    };
-    return f;
-};
-export const merge = (cmp) => {
-    const tailReduce = mergeTail;
-    return genericMerge({ reduceOp: cmpReduce(cmp), tailReduce })(null);
-};
-const cmpReduce = (cmp) => () => a => b => {
-    const sign = cmp(a)(b);
-    return [sign === 1 ? b : a, sign, null];
-};
-const mergeTail = () => identity;
-const tailReduce = () => () => null;
-const intersectReduce = (cmp) => () => a => b => {
-    const sign = cmp(a)(b);
-    return [sign === 0 ? a : null, sign, null];
-};
-export const intersect = (cmp) => genericMerge({ reduceOp: intersectReduce(cmp), tailReduce })(null);
-export const find = (cmp) => (value) => (array) => {
-    const cmpValue = cmp(value);
-    const pos = bsearch(array.length)(mid => cmpValue(array[mid]));
-    return pos < array.length && cmpValue(array[pos]) === 0 ? value : null;
-};

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

@@ -1,4 +0,0 @@
-export declare const proof: {
-    sortedMergre: (() => void)[];
-    find: (() => void)[];
-};

package/fjs/types/sorted_list/proof.f.js

@@ -1,46 +0,0 @@
-import { find, merge } from './module.f.js';
-import { stringify } from '../../media/json/module.f.js';
-import { sort } from '../object/module.f.js';
-import { toArray, countdown, length } from '../list/module.f.js';
-import { flip } from '../function/module.f.js';
-import { cmp } from '../number/module.f.js';
-import { assert, assertEq } from '../../asserts/module.f.js';
-const str = stringify(sort);
-const reverseCmp = flip(cmp);
-export const proof = {
-    sortedMergre: [
-        () => {
-            const result = str(toArray(merge(cmp)([2, 3, 4])([1, 3, 5])));
-            assertEq(result, '[1,2,3,4,5]');
-        },
-        () => {
-            const result = str(toArray(merge(cmp)([1, 2, 3])([])));
-            assertEq(result, '[1,2,3]');
-        },
-        () => {
-            const n = 10_000;
-            const list = countdown(n);
-            const result = merge(reverseCmp)(list)(list);
-            const len = length(result);
-            assert(len == n, result);
-        }
-    ],
-    find: [
-        () => {
-            const result = find(cmp)(0)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
-            assertEq(result, 0);
-        },
-        () => {
-            const result = find(cmp)(3)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
-            assertEq(result, null);
-        },
-        () => {
-            const result = find(cmp)(77)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
-            assertEq(result, null);
-        },
-        () => {
-            const result = find(cmp)(80)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
-            assertEq(result, 80);
-        }
-    ]
-};

package/fjs/types/sorted_set/module.f.d.ts

@@ -1,33 +0,0 @@
-/**
- * A sorted set, implemented as a sorted array.
- *
- * @module
- *
- * @note
- *
- * All input arrays must be pre-sorted according to the provided comparison function (`Cmp<T>`).
- * The correctness of these functions depend on this requirement.
- *
- * @example
- *
- * ```js
- * import { union, intersect, has } from './module.f.ts'
- *
- * const cmp = (a: number) => (b: number) => a < b ? -1 : a > b ? 1 : 0
- *
- * const setA = [1, 3, 5]
- * const setB = [3, 4, 5]
- *
- * const unionSet = union(cmp)(setA)(setB) // [1, 3, 4, 5]
- *
- * const intersectionSet = intersect(cmp)(setA)(setB) // [3, 5]
- *
- * has(cmp)(3)(setA) // true
- * has(cmp)(2)(setA) // false
- * ```
- */
-import type { Cmp } from '../function/compare/module.f.ts';
-export type SortedSet<T> = readonly T[];
-export declare const union: <T>(cmp: Cmp<T>) => (a: SortedSet<T>) => (b: SortedSet<T>) => SortedSet<T>;
-export declare const intersect: <T>(cmp: Cmp<T>) => (a: SortedSet<T>) => (b: SortedSet<T>) => SortedSet<T>;
-export declare const has: <T>(cmp: Cmp<T>) => (value: T) => (set: SortedSet<T>) => boolean;

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

@@ -1,5 +0,0 @@
-import { toArray } from "../list/module.f.js";
-import { merge, intersect as listIntersect, find } from '../sorted_list/module.f.js';
-export const union = cmp => a => b => toArray(merge(cmp)(a)(b));
-export const intersect = cmp => a => b => toArray(listIntersect(cmp)(a)(b));
-export const has = cmp => value => set => find(cmp)(value)(set) === value;

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

@@ -1,6 +0,0 @@
-export declare const proof: {
-    example: () => void;
-    union: (() => void)[];
-    intersect: (() => void)[];
-    has: (() => void)[];
-};

package/fjs/types/sorted_set/proof.f.js

@@ -1,67 +0,0 @@
-import { has, intersect, union } from './module.f.js';
-import { stringify } from '../../media/json/module.f.js';
-import { sort } from '../object/module.f.js';
-import { toArray, countdown, length } from '../list/module.f.js';
-import { flip } from '../function/module.f.js';
-import { cmp } from '../number/module.f.js';
-import { assert, assertEq } from '../../asserts/module.f.js';
-const str = a => stringify(sort)(a);
-const reverseCmp = flip(cmp);
-export const proof = {
-    example: () => {
-        const cmp = (a) => (b) => a < b ? -1 : a > b ? 1 : 0;
-        const setA = [1, 3, 5];
-        const setB = [3, 4, 5];
-        const unionSet = union(cmp)(setA)(setB); // [1, 3, 4, 5]
-        assertEq(str(unionSet), '[1,3,4,5]', 0);
-        const intersectionSet = intersect(cmp)(setA)(setB); // [3, 5]
-        assertEq(str(intersectionSet), '[3,5]', 1);
-        assert(has(cmp)(3)(setA), 2);
-        assert(!(has(cmp)(2)(setA)), 3);
-    },
-    union: [
-        () => {
-            const result = str(toArray(union(cmp)([2, 3, 4])([1, 3, 5])));
-            assertEq(result, '[1,2,3,4,5]');
-        },
-        () => {
-            const result = str(toArray(union(cmp)([1, 2, 3])([])));
-            assertEq(result, '[1,2,3]');
-        },
-        () => {
-            const n = 10_000;
-            const sortedSet = toArray(countdown(n));
-            const result = union(reverseCmp)(sortedSet)(sortedSet);
-            const len = length(result);
-            assert(len == n, result);
-        }
-    ],
-    intersect: [
-        () => {
-            const result = str(toArray(intersect(cmp)([2, 3, 4])([1, 3, 5])));
-            assertEq(result, '[3]');
-        },
-        () => {
-            const result = str(toArray(intersect(cmp)([1, 2, 3])([])));
-            assertEq(result, '[]');
-        }
-    ],
-    has: [
-        () => {
-            const result = has(cmp)(0)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
-            assert(result, result);
-        },
-        () => {
-            const result = has(cmp)(3)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
-            assert(!(result), result);
-        },
-        () => {
-            const result = has(cmp)(77)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
-            assert(!(result), result);
-        },
-        () => {
-            const result = has(cmp)(80)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
-            assert(result, result);
-        }
-    ]
-};

package/fjs/types/string/module.f.d.ts

@@ -1,24 +0,0 @@
-/**
- * Utility functions for working with strings and lists of strings.
- *
- * @module
- *
- * @example
- *
- * ```js
- * import { join, concat, repeat, cmp } from './module.f.ts'
- *
- * const words = ['hello', 'world']
- * join(' ')(words) // 'hello world'
- * concat(words) // 'helloworld'
- * repeat('abc')(3) // 'abcabcabc'
- * cmp('apple')('banana') // -1
- * ```
- */
-import { type List } from '../list/module.f.ts';
-import { type Sign } from '../function/compare/module.f.ts';
-export declare const join: (_: string) => (input: List<string>) => string;
-export declare const concat: (input: List<string>) => string;
-export declare const repeat: (n: string) => (v: number) => string;
-export declare const cmp: (a: string) => (b: string) => Sign;
-export declare const splitAt: (p: number) => (v: string) => readonly [string, string];

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

@@ -1,35 +0,0 @@
-/**
- * Utility functions for working with strings and lists of strings.
- *
- * @module
- *
- * @example
- *
- * ```js
- * import { join, concat, repeat, cmp } from './module.f.ts'
- *
- * const words = ['hello', 'world']
- * join(' ')(words) // 'hello world'
- * concat(words) // 'helloworld'
- * repeat('abc')(3) // 'abcabcabc'
- * cmp('apple')('banana') // -1
- * ```
- */
-import { reduce as listReduce, repeat as listRepeat } from '../list/module.f.js';
-import { compose } from '../function/module.f.js';
-import { cmp as uCmp } from '../function/compare/module.f.js';
-import { join as joinOp } from '../function/operator/module.f.js';
-import { fold } from '../../common/monoid/module.f.js';
-// `join`'s per-separator reduction is seeded at `''` but is *not* a monoid fold:
-// `joinOp(sep)` has no identity (`joinOp(sep)('')(x)` prepends a separator), so
-// it stays a hand-seeded `reduce` rather than going through `monoid.fold`.
-const reduce = o => listReduce(o)('');
-export const join = compose(joinOp)(reduce);
-// String concatenation with identity `''` is a lawful monoid, so `concat` is a
-// monoid fold. The operation is accumulator-first (`a` on the left), matching
-// `monoid.fold`'s convention — unlike the element-first `concat` in
-// `function/operator`, which is written for `list.reduce`.
-export const concat = fold({ identity: '', operation: a => b => a + b });
-export const repeat = v => compose(listRepeat(v))(concat);
-export const cmp = uCmp;
-export const splitAt = (p) => (v) => [v.substring(0, p), v.substring(p)];