functionalscript 0.43.0 → 0.44.0

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

@@ -1,112 +0,0 @@
-import { repeat } from '../../common/monoid/module.f.js';
-import { assertNotNullish } from '../../asserts/module.f.js';
-/**
- * Creates a prime field with the specified prime modulus and associated operations.
- *
- * @param p - A prime number to define the field.
- * @returns The prime field object.
- */
-export const prime_field = (p) => {
-    const sub = a => b => {
-        const r = a - b;
-        return r < 0 ? r + p : r;
-    };
-    const mul = a => b => a * b % p;
-    const reciprocal = a => {
-        if (a === 0n) {
-            throw '1/0';
-        }
-        let a1 = a;
-        let a0 = p;
-        let f0 = 0n;
-        let f1 = 1n;
-        while (a1 !== 1n) {
-            const q = a0 / a1;
-            const a2 = a0 % a1;
-            a0 = a1;
-            a1 = a2;
-            const f2 = sub(f0)(mul(f1)(q));
-            f0 = f1;
-            f1 = f2;
-        }
-        return f1;
-    };
-    const middle = p >> 1n;
-    const pow2 = a => mul(a)(a);
-    const pow = repeat({ identity: 1n, operation: mul });
-    const add = a => b => {
-        const r = a + b;
-        return r < p ? r : r - p;
-    };
-    const reduce = x => {
-        const r = x % p;
-        return r < 0n ? add(p)(r) : r;
-    };
-    const max = p - 1n;
-    // Euler's exponent is `(p - 1) / 2`; use `max`, not `p`, so `p === 2n`
-    // gives exponent `0n` instead of `1n`.
-    // 0 is a square mod p; Euler's criterion needs a separate case because 0^e = 0.
-    const powHalf = pow(max >> 1n);
-    const quadRes = (x) => {
-        const v = reduce(x);
-        return v === 0n || powHalf(v) === 1n;
-    };
-    return {
-        p,
-        middle,
-        max,
-        neg: a => a === 0n ? 0n : p - a,
-        sub,
-        add,
-        abs: a => middle < a ? p - a : a,
-        mul,
-        reciprocal,
-        div: a => b => mul(a)(reciprocal(b)),
-        pow,
-        pow2,
-        pow3: a => mul(a)(pow2(a)),
-        reduce,
-        quadRes,
-    };
-};
-/**
- * Computes the square root of a number in a prime field.
- *
- * @throws If the prime modulus `p` does not satisfy `p % 4 == 3`.
- *
- * @example
- *
- * ```js
- * const field = prime_field(7n);
- * const root = sqrt(field)(4n);
- * if (root !== 2n) { throw root }
- * ```
- */
-export const sqrt = ({ p, pow, pow2 }) => {
-    if ((p & 3n) !== 3n) {
-        throw 'sqrt';
-    }
-    const sqrt_k = (p + 1n) >> 2n;
-    const psk = pow(sqrt_k);
-    return a => {
-        const result = psk(a);
-        return pow2(result) === a ? result : null;
-    };
-};
-/**
- * Modular square root mod `p` (`p ≡ 3 (mod 4)`); uses {@link PrimeField.neg} when `x` is not a residue.
- */
-export const modSqrt = (field) => {
-    const { neg, reduce } = field;
-    const sqrt_p = sqrt(field);
-    return x => {
-        const v = reduce(x);
-        const r = sqrt_p(v);
-        // For a prime `p ≡ 3 (mod 4)`, `−1` is a non-residue, so exactly one of
-        // `±v` is a quadratic residue: if `v` has no root, `neg(v)` must — hence
-        // `s` is non-null. `sqrt` already enforces `p ≡ 3 (mod 4)`, but primality
-        // is never checked, so the only way to reach `s === null` is a *composite*
-        // modulus (where the residue argument breaks).
-        return r !== null ? r : assertNotNullish(sqrt_p(neg(v)), 'modSqrt');
-    };
-};

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

@@ -1,128 +0,0 @@
-import { modSqrt, prime_field, sqrt } from './module.f.js';
-import { assert, assertEq } from '../../asserts/module.f.js';
-export const proof = {
-    throw: {
-        reciprocal_zero: () => prime_field(7n).reciprocal(0n),
-        sqrt_bad_prime: () => sqrt(prime_field(5n)),
-    },
-    prime_field_test: () => {
-        const p = 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2fn;
-        const f = prime_field(p);
-        const sqrt_f = sqrt(f);
-        return {
-            neg: () => {
-                assertEq(f.neg(0n), 0n);
-                assertEq(f.neg(1n), p - 1n);
-            },
-            sub: () => {
-                assertEq(f.sub(10n)(4n), 6n);
-                assertEq(f.sub(11n)(14n), p - 3n);
-            },
-            add: () => {
-                assertEq(f.add(13n)(24n), 37n);
-                assertEq(f.add(77n)(f.neg(12n)), 65n);
-            },
-            mul: () => {
-                assertEq(f.mul(100n)(0n), 0n);
-                assertEq(f.mul(101n)(205n), 20705n);
-                assertEq(f.mul(304n)(f.neg(1n)), f.neg(304n));
-                assertEq(f.mul(f.neg(507n))(609n), f.neg(308763n));
-                assertEq(f.mul(f.neg(713n))(f.neg(825n)), 588225n);
-            },
-            reciprocal: () => {
-                let i = 1n;
-                while (i < 10000n) {
-                    assertEq(f.mul(f.reciprocal(i))(i), 1n);
-                    ++i;
-                }
-            },
-            pow: () => {
-                const test = a => {
-                    assertEq(f.pow(0n)(a), 1n);
-                    assertEq(f.pow(1n)(a), a);
-                    // https://en.wikipedia.org/wiki/Fermat%27s_little_theorem
-                    // a^(p-1) % p = 1
-                    assertEq(f.abs(f.pow(f.middle)(a)), 1n);
-                    assertEq(f.pow(f.sub(f.max)(1n))(a), f.reciprocal(a));
-                    assertEq(f.pow(f.max)(a), 1n);
-                };
-                // 0
-                assertEq(f.pow(0n)(0n), 1n);
-                assertEq(f.pow(f.max)(0n), 0n);
-                // 1
-                test(1n);
-                // 2
-                test(2n);
-                assertEq(f.pow(2n)(2n), 4n);
-                assertEq(f.pow(3n)(2n), 8n);
-                assertEq(f.pow(128n)(2n), 1n << 128n);
-                // 3
-                test(3n);
-                assertEq(f.pow(2n)(3n), 9n);
-                assertEq(f.pow(3n)(3n), 27n);
-                assertEq(f.pow(100n)(3n), 3n ** 100n);
-                assertEq(f.pow(110n)(3n), 3n ** 110n);
-                assertEq(f.pow(120n)(3n), 3n ** 120n);
-                assertEq(f.pow(121n)(3n), 3n ** 121n);
-                //
-                test(f.middle);
-                test(f.max - 1n);
-                test(f.max);
-            },
-            sqrtExample: () => {
-                const field = prime_field(7n);
-                assertEq(sqrt(field)(4n), 2n);
-            },
-            sqrt: () => {
-                const test = a => {
-                    const a2 = f.mul(a)(a);
-                    const s = sqrt_f(a2);
-                    assert(s === null || f.abs(s) === f.abs(a), 'sqrt');
-                };
-                let i = 1n;
-                while (i < 1000n) {
-                    test(i);
-                    ++i;
-                }
-                test(f.middle);
-                test(f.max);
-            },
-            reduce: () => {
-                assertEq(f.reduce(13n), 13n);
-                assertEq(f.reduce(-1n), p - 1n);
-            },
-            quadRes: () => {
-                assert(f.quadRes(0n), 0n);
-                assert(f.quadRes(1n), 1n);
-                assert(f.quadRes(p), p);
-                assert(!f.quadRes(3n), 3n);
-                const f2 = prime_field(2n);
-                assert(f2.quadRes(0n), '0 mod 2');
-                assert(f2.quadRes(1n), '1 mod 2');
-            },
-            modSqrt: () => {
-                const root = modSqrt(f);
-                assertEq(root(4n), 2n);
-                assertEq(f.pow2(root(2n)), 2n);
-            },
-            div: () => {
-                assertEq(f.div(6n)(2n), 3n);
-                assertEq(f.div(0n)(5n), 0n);
-                assertEq(f.div(1n)(1n), 1n);
-            },
-            pow3: () => {
-                assertEq(f.pow3(0n), 0n);
-                assertEq(f.pow3(1n), 1n);
-                assertEq(f.pow3(2n), 8n);
-                assertEq(f.pow3(3n), 27n);
-                assertEq(f.pow3(10n), 1000n);
-            },
-            abs: () => {
-                assertEq(f.abs(0n), 0n);
-                assertEq(f.abs(1n), 1n);
-                assertEq(f.abs(f.neg(1n)), 1n);
-                assertEq(f.abs(f.middle), f.middle);
-            },
-        };
-    }
-};

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

@@ -1,8 +0,0 @@
-/**
- * Range and interval utilities for numeric boundaries.
- *
- * @module
- */
-export type Range = readonly [number, number];
-export declare const contains: (...range: Range) => (i: number) => boolean;
-export declare const one: (i: number) => Range;

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

@@ -1,2 +0,0 @@
-export const contains = (b, e) => i => b <= i && i <= e;
-export const one = a => [a, a];

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

@@ -1,9 +0,0 @@
-import { contains } from './module.f.js';
-import { assert } from '../../asserts/module.f.js';
-export const proof = () => {
-    assert(contains(0, 5)(1), 1);
-    assert(contains(0, 5)(0), 0);
-    assert(contains(0, 5)(5), 5);
-    assert(!(contains(0, 5)(-1)), -1);
-    assert(!(contains(0, 5)(6)), 6);
-};

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

@@ -1,92 +0,0 @@
-/**
- * Utility functions and types for managing and merging range maps.
- *
- * @module
- *
- * @example
- *
- * ```js
- * const rmOps = rangeMap({
- *     union: a => b => a | b,
- *     equal: a => b => a === b,
- *     def: 0,
- * })
- *
- * // Create range maps
- * const range1 = rmOps.fromRange(2)([0, 10])
- * const range2 = rmOps.fromRange(5)([5, 15])
- *
- * // Merge range maps
- * const merged = toArray(rmOps.merge(range1)(range2))
- *
- * // Retrieve values from the merged range map
- * const get = rmOps.get(merged)
- * //
- * if (get(-1) !== 0) { throw 'error' }
- * //
- * if (get(0) !== 2) { throw 'error' }
- * if (get(2) !== 2) { throw 'error' }
- * // overlapped: 2 | 5 = 7
- * if (get(7) !== 7) { throw 'error' }
- * //
- * if (get(12) !== 5) { throw 'error' }
- * if (get(15) !== 5) { throw 'error' }
- * //
- * if (get(16) !== 0) { throw 'error' }
- * ```
- */
-import { type SortedList } from '../sorted_list/module.f.ts';
-import type { Reduce, Equal } from '../function/operator/module.f.ts';
-import type { Range } from '../range/module.f.ts';
-export type Entry<T> = [T, number];
-/**
- * A sorted list of entries, where each entry is a tuple `[T, number]` that maps a value of type `T` to an upper boundary
- * of a numeric range.
- */
-export type RangeMap<T> = SortedList<Entry<T>>;
-export type RangeMapArray<T> = readonly Entry<T>[];
-/**
- * Defines the properties and operations required for managing range maps.
- */
-export type Properties<T> = {
-    /**
-     * A function to merge two values of type `T`. This defines how overlapping ranges are combined.
-     */
-    readonly union: Reduce<T>;
-    /**
-     * A function to check equality between two values of type `T`.
-     */
-    readonly equal: Equal<T>;
-    /**
-     * The default value used when no range matches or for initializing ranges.
-     */
-    readonly def: T;
-};
-export type RangeMerge<T> = Reduce<RangeMap<T>>;
-export declare const merge: <T>(op: Properties<T>) => RangeMerge<T>;
-export declare const get: <T>(def: T) => (rm: RangeMapArray<T>) => (value: number) => T;
-export declare const fromRange: <T>(def: T) => (value: T) => (r: Range) => RangeMapArray<T>;
-/**
- * Represents a set of operations for managing range maps.
- */
-export type RangeMapOp<T> = {
-    /**
-     * Merges two range maps into a single range map.
-     */
-    readonly merge: RangeMerge<T>;
-    /**
-     * Retrieves the value associated with a given numeric range.
-     */
-    readonly get: (rm: RangeMapArray<T>) => (value: number) => T;
-    /**
-     * Constructs a range map for a single numeric range and value.
-     */
-    readonly fromRange: (value: T) => (r: Range) => RangeMapArray<T>;
-};
-/**
- * Creates a set of operations for managing range maps using the specified properties.
- *
- * @param op - The properties defining union and equality operations and the default value.
- * @returns An object containing operations for merging, retrieving, and constructing range maps.
- */
-export declare const rangeMap: <T>(op: Properties<T>) => RangeMapOp<T>;

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

@@ -1,82 +0,0 @@
-/**
- * Utility functions and types for managing and merging range maps.
- *
- * @module
- *
- * @example
- *
- * ```js
- * const rmOps = rangeMap({
- *     union: a => b => a | b,
- *     equal: a => b => a === b,
- *     def: 0,
- * })
- *
- * // Create range maps
- * const range1 = rmOps.fromRange(2)([0, 10])
- * const range2 = rmOps.fromRange(5)([5, 15])
- *
- * // Merge range maps
- * const merged = toArray(rmOps.merge(range1)(range2))
- *
- * // Retrieve values from the merged range map
- * const get = rmOps.get(merged)
- * //
- * if (get(-1) !== 0) { throw 'error' }
- * //
- * if (get(0) !== 2) { throw 'error' }
- * if (get(2) !== 2) { throw 'error' }
- * // overlapped: 2 | 5 = 7
- * if (get(7) !== 7) { throw 'error' }
- * //
- * if (get(12) !== 5) { throw 'error' }
- * if (get(15) !== 5) { throw 'error' }
- * //
- * if (get(16) !== 0) { throw 'error' }
- * ```
- */
-import { genericMerge } from '../sorted_list/module.f.js';
-import { next } from '../list/module.f.js';
-import { cmp } from '../number/module.f.js';
-import { bsearch } from '../function/compare/module.f.js';
-const reduceOp = ({ union, equal }) => state => ([aItem, aMax]) => ([bItem, bMax]) => {
-    const sign = cmp(aMax)(bMax);
-    const min = sign === 1 ? bMax : aMax;
-    const u = union(aItem)(bItem);
-    const newState = state !== null && equal(state[0])(u) ? null : state;
-    return [newState, sign, [u, min]];
-};
-const tailReduce = equal => state => tail => {
-    if (state === null) {
-        return tail;
-    }
-    const tailResult = next(tail);
-    if (tailResult === null) {
-        return [state];
-    }
-    if (equal(state[0])(tailResult.first[0])) {
-        return tailResult;
-    }
-    return { first: state, tail: tailResult };
-};
-export const merge = op => genericMerge({ reduceOp: reduceOp(op), tailReduce: tailReduce(op.equal) })(null);
-export const get = def => rm => {
-    const length = rm.length;
-    const search = bsearch(length);
-    return value => {
-        const pos = search(mid => value <= rm[mid][1] ? -1 : 1);
-        return pos < length ? rm[pos][0] : def;
-    };
-};
-export const fromRange = def => v => ([a, b]) => [[def, a - 1], [v, b]];
-/**
- * Creates a set of operations for managing range maps using the specified properties.
- *
- * @param op - The properties defining union and equality operations and the default value.
- * @returns An object containing operations for merging, retrieving, and constructing range maps.
- */
-export const rangeMap = (op) => ({
-    merge: merge(op),
-    get: get(op.def),
-    fromRange: fromRange(op.def),
-});

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

@@ -1,6 +0,0 @@
-export declare const proof: {
-    example: () => void;
-    merge: (() => void)[];
-    get: () => (() => void)[];
-    fromRange: () => (() => void)[];
-};

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

@@ -1,151 +0,0 @@
-import { get, merge, fromRange, rangeMap } from './module.f.js';
-import { stringify } from '../../media/json/module.f.js';
-import { sort } from '../object/module.f.js';
-import { union } from '../sorted_set/module.f.js';
-import { equal, toArray } from '../list/module.f.js';
-import { strictEqual } from '../function/operator/module.f.js';
-import { cmp } from '../string/module.f.js';
-import { assertEq } from '../../asserts/module.f.js';
-const str = stringify(sort);
-const op = {
-    union: union(cmp),
-    equal: equal(strictEqual),
-    def: []
-};
-export const proof = {
-    example: () => {
-        const rmOps = rangeMap({
-            union: a => b => a | b,
-            equal: a => b => a === b,
-            def: 0,
-        });
-        // Create range maps
-        const range1 = rmOps.fromRange(2)([0, 10]);
-        const range2 = rmOps.fromRange(5)([5, 15]);
-        // Merge range maps
-        const merged = toArray(rmOps.merge(range1)(range2));
-        // Retrieve values from the merged range map
-        //
-        const get = rmOps.get(merged);
-        assertEq(get(-1), 0, 'error');
-        //
-        assertEq(get(0), 2, 'error');
-        assertEq(get(2), 2, 'error');
-        // 2 | 5 = 7
-        assertEq(get(7), 7, 'error');
-        //
-        assertEq(get(12), 5, 'error');
-        assertEq(get(15), 5, 'error');
-        //
-        assertEq(get(16), 0, 'error');
-    },
-    merge: [
-        () => {
-            const a = [[['a'], 1], [['b'], 2]];
-            const b = null;
-            const merged = merge(op)(a)(b);
-            const result = str(toArray(merged));
-            assertEq(result, '[[["a"],1],[["b"],2]]');
-        },
-        () => {
-            const a = null;
-            const b = [[['a'], 1], [['b'], 2]];
-            const merged = merge(op)(a)(b);
-            const result = str(toArray(merged));
-            assertEq(result, '[[["a"],1],[["b"],2]]');
-        },
-        () => {
-            const a = [[['a'], 1], [['b'], 2]];
-            const b = [[['a'], 1], [['b'], 2]];
-            const merged = merge(op)(a)(b);
-            const result = str(toArray(merged));
-            assertEq(result, '[[["a"],1],[["b"],2]]');
-        },
-        () => {
-            const a = [[['a'], 1], [['c'], 3]];
-            const b = [[['b'], 2], [['d'], 4]];
-            const merged = merge(op)(a)(b);
-            const result = str(toArray(merged));
-            assertEq(result, '[[["a","b"],1],[["b","c"],2],[["c","d"],3],[["d"],4]]');
-        },
-        () => {
-            const a = [[['a'], 1], [['d'], 4]];
-            const b = [[['b'], 2], [['c'], 3]];
-            const merged = merge(op)(a)(b);
-            const result = str(toArray(merged));
-            assertEq(result, '[[["a","b"],1],[["b","d"],2],[["c","d"],3],[["d"],4]]');
-        },
-        () => {
-            const a = [[['a'], 1], [['b'], 2]];
-            const b = [[['b'], 1], [['a'], 2]];
-            const merged = merge(op)(a)(b);
-            const result = str(toArray(merged));
-            assertEq(result, '[[["a","b"],2]]');
-        },
-        () => {
-            const a = [[['a'], 1], [['b'], 2], [['a'], 3]];
-            const b = [[['a'], 5]];
-            const merged = merge(op)(a)(b);
-            const result = str(toArray(merged));
-            assertEq(result, '[[["a"],1],[["a","b"],2],[["a"],5]]');
-        }
-    ],
-    get: () => {
-        const sortedSetEmpty = [];
-        const at = get(sortedSetEmpty);
-        return [
-            () => {
-                const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
-                const result = str(at(rm)(5));
-                assertEq(result, '["a"]');
-            },
-            () => {
-                const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
-                const result = str(at(rm)(10));
-                assertEq(result, '["a"]');
-            },
-            () => {
-                const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
-                const result = str(at(rm)(15));
-                assertEq(result, '["b"]');
-            },
-            () => {
-                const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
-                const result = str(at(rm)(20));
-                assertEq(result, '["b"]');
-            },
-            () => {
-                const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
-                const result = str(at(rm)(25));
-                assertEq(result, '["c"]');
-            },
-            () => {
-                const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
-                const result = str(at(rm)(30));
-                assertEq(result, '["c"]');
-            },
-            () => {
-                const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
-                const result = str(at(rm)(35));
-                assertEq(result, '[]');
-            },
-            () => {
-                const rm = [];
-                const result = str(at(rm)(10));
-                assertEq(result, '[]');
-            }
-        ];
-    },
-    fromRange: () => {
-        const def = -1;
-        const rm = fromRange(def)(42)([1, 7]);
-        const g = get(def)(rm);
-        return [
-            () => assertEq(g(0), -1),
-            () => assertEq(g(1), 42),
-            () => assertEq(g(3), 42),
-            () => assertEq(g(7), 42),
-            () => assertEq(g(9), -1),
-        ];
-    },
-};

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

@@ -1,5 +0,0 @@
-/**
- * Constructs a range set containing a single numeric range.
- */
-export declare const fromRange: (r: import("../range/module.f.ts").Range) => import("../range_map/module.f.ts").RangeMapArray<boolean>;
-export declare const merge: import("../range_map/module.f.ts").RangeMerge<boolean>, get: (rm: import("../range_map/module.f.ts").RangeMapArray<boolean>) => (value: number) => boolean;

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

@@ -1,16 +0,0 @@
-/**
- * A set of numeric ranges, represented as a `range_map` of `boolean`.
- *
- * @module
- */
-import { rangeMap } from '../range_map/module.f.js';
-const map = rangeMap({
-    union: a => b => a || b,
-    equal: a => b => a === b,
-    def: false,
-});
-/**
- * Constructs a range set containing a single numeric range.
- */
-export const fromRange = map.fromRange(true);
-export const { merge, get } = map;

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

@@ -1 +0,0 @@
-export declare const proof: () => void;

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

@@ -1,19 +0,0 @@
-import { assert } from "../../asserts/module.f.js";
-import { toArray } from "../list/module.f.js";
-import { fromRange, merge, get } from "./module.f.js";
-import {} from '../range/module.f.js';
-const c = (a) => a.charCodeAt(0);
-const range = ([a, b]) => [c(a), c(b)];
-export const proof = () => {
-    const digit = fromRange(range('09'));
-    const initial = toArray(merge(fromRange(range('AZ')))(fromRange(range('az'))));
-    const isInitial = get(initial);
-    assert(!isInitial(0));
-    assert(isInitial(c('a')));
-    assert(!isInitial(c('1')));
-    assert(isInitial(c('Z')));
-    const isNext = get(toArray(merge(initial)(digit)));
-    assert(isNext(c('0')));
-    assert(isNext(c('A')));
-    assert(!isNext(c('@')));
-};

package/fjs/types/result/module.d.ts

@@ -1,3 +0,0 @@
-import { type Result } from './module.f.ts';
-export declare const tryCatch: <T>(f: () => T) => Result<T, unknown>;
-export declare const asyncTryCatch: <T>(f: () => Promise<T>) => Promise<Result<T, unknown>>;