functionalscript 0.43.1 → 0.45.0

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

@@ -1,330 +0,0 @@
-import { length, concat, countdown, cycle, drop, dropWhile, entries, every, filter, find, flat, flatMap, map, next, reduce, reverse, scan, some, take, takeWhile, toArray, zip, first, filterMap, isEmpty, equal, tryFold } from './module.f.js';
-import { stringify } from '../../media/json/module.f.js';
-import { sort } from '../object/module.f.js';
-import { addition, strictEqual, reduceToScan } from '../function/operator/module.f.js';
-import { assert, assertEq, assertNotNullish } from '../../asserts/module.f.js';
-const str = sequence => stringify(sort)(toArray(sequence));
-const stringifyTest = () => {
-    const s = str([1, 2, 3]);
-    assertEq(s, '[1,2,3]');
-};
-const cycleTest = [
-    () => {
-        const x = str(toArray(take(10)(cycle([1, 2, 3]))));
-        assertEq(x, '[1,2,3,1,2,3,1,2,3,1]');
-    },
-    () => {
-        const x = str(toArray(cycle([])));
-        assertEq(x, '[]');
-    },
-];
-const countdownTest = () => {
-    const result = str(countdown(10));
-    assertEq(result, '[9,8,7,6,5,4,3,2,1,0]');
-};
-const flatTest = () => {
-    const result = str(flat([[1, 2, 3], [4, 5], [6], [], [7, 8, 9]]));
-    assertEq(result, '[1,2,3,4,5,6,7,8,9]');
-};
-const concatTest = () => {
-    const result = concat([1])([2]);
-    const x = assertNotNullish(next(result));
-    assertEq(x.first, 1, x);
-};
-const flatMapTest = () => {
-    const result = str(flatMap((x) => [x, x * 2, x * 3])([0, 1, 2, 3]));
-    assertEq(result, '[0,0,0,1,2,3,2,4,6,3,6,9]');
-};
-const takeTest = [
-    () => {
-        const result = str(take(3)([1, 2, 3, 4, 5, 6, 7, 8, 9]));
-        assertEq(result, '[1,2,3]');
-    },
-    () => {
-        const result = str(take(20)([1, 2, 3, 4, 5, 6, 7, 8, 9]));
-        assertEq(result, '[1,2,3,4,5,6,7,8,9]');
-    },
-    () => {
-        const result = str(take(0)([1, 2, 3, 4, 5, 6, 7, 8, 9]));
-        assertEq(result, '[]');
-    }
-];
-const findTest = [
-    () => {
-        const result = find(null)((x) => x % 2 === 0)([1, 3, 5, 7]);
-        assertEq(result, null);
-    },
-    () => {
-        const result = find(null)((x) => x % 2 === 0)([1, 2, 3, 4]);
-        assertEq(result, 2);
-    }
-];
-const takeWhileTest = [
-    () => {
-        const result = str(takeWhile((x) => x < 10)([1, 2, 3, 4, 5, 10, 11]));
-        assertEq(result, '[1,2,3,4,5]');
-    },
-    () => {
-        const result = str(takeWhile((x) => x < 6)([1, 2, 3, 4, 5, 6, 7, 8, 9]));
-        assertEq(result, '[1,2,3,4,5]');
-    }
-];
-const dropWhileTest = () => {
-    const result = str(dropWhile((x) => x < 10)([1, 2, 3, 4, 5, 10, 11]));
-    assertEq(result, '[10,11]');
-};
-const dropTest = [
-    () => {
-        const result = str(drop(3)([1, 2, 3, 4, 5, 10, 11]));
-        assertEq(result, '[4,5,10,11]');
-    },
-    () => {
-        const result = str(drop(0)([1, 2, 3, 4, 5, 10, 11]));
-        assertEq(result, '[1,2,3,4,5,10,11]');
-    },
-    () => {
-        const result = str(drop(10)([1, 2, 3, 4, 5, 10, 11]));
-        assertEq(result, '[]');
-    }
-];
-const additionTests = [
-    () => {
-        const op = reduceToScan(addition);
-        const result = str(scan(op)([2, 3, 4, 5]));
-        assertEq(result, '[2,5,9,14]');
-    },
-    () => {
-        const result = reduce(addition)(null)([2, 3, 4, 5]);
-        assertEq(result, 14);
-    },
-    () => {
-        const result = reduce(addition)(null)([]);
-        assertEq(result, null);
-    }
-];
-const entriesTest = [
-    () => {
-        const result = str(entries([]));
-        assertEq(result, '[]');
-    },
-    () => {
-        const result = str(entries(['hello', 'world']));
-        assertEq(result, '[[0,"hello"],[1,"world"]]');
-    }
-];
-const sumUpTo = (limit) => ({
-    init: 0,
-    update: (i, state) => {
-        const next = state + i;
-        return next > limit ? null : next;
-    },
-    end: (state) => state * 10,
-});
-const tryFoldTest = [
-    () => {
-        const result = tryFold(sumUpTo(100))([1, 2, 3]);
-        assertEq(result, 60);
-    },
-    () => {
-        const result = tryFold(sumUpTo(4))([1, 2, 3]);
-        assertEq(result, null);
-    },
-    () => {
-        const result = tryFold(sumUpTo(100))([]);
-        assertEq(result, 0);
-    },
-];
-const reverseTest = [
-    () => {
-        const result = str(reverse([]));
-        assertEq(result, '[]');
-    },
-    () => {
-        const result = str(reverse([1, 2, 3, 4, 5]));
-        assertEq(result, '[5,4,3,2,1]');
-    }
-];
-const zipTest = [
-    () => {
-        const result = str(zip([0, 1, 2])(['a', 'b', 'c', 'd']));
-        assertEq(result, '[[0,"a"],[1,"b"],[2,"c"]]');
-    },
-    () => {
-        const result = str(zip([0, 1, 2])(['a', 'b']));
-        assertEq(result, '[[0,"a"],[1,"b"]]');
-    }
-];
-const logic = () => {
-    const map5 = map((x) => x > 5);
-    return [
-        () => {
-            const result = some(map5([0, 1, 7]));
-            assert(result, result);
-        },
-        () => {
-            const result = some(map5([0, 1, 4]));
-            assert(!(result), result);
-        },
-        () => {
-            const result = some(map5([]));
-            assert(!(result), result);
-        },
-        () => {
-            const result = every(map5([0, 1, 7]));
-            assert(!(result), result);
-        },
-        () => {
-            const result = every(map5([6, 11, 7]));
-            assert(result, result);
-        },
-        () => {
-            const result = every(map5([]));
-            assert(result, result);
-        }
-    ];
-};
-// stress tests
-const stress = () => ({
-    toArray: () => {
-        // 200_000_000 is too much
-        const n = 100_000_000;
-        const result = toArray(countdown(n));
-        assertEq(result.length, n);
-        const len = length(filter((x) => x > n)(result));
-        assertEq(len, 0);
-    },
-    first: () => {
-        // 100_000_000 is too much
-        const n = 50_000_000;
-        const result = toArray(countdown(n));
-        assertEq(result.length, n);
-        const f = first(null)(result);
-        assertEq(f, n - 1);
-    },
-    concatBack: () => {
-        let sequence = [];
-        // 20_000_000 is too much
-        // 10_000_000 is too much for Deno 1
-        for (let i = 0; i < 5_000_000; ++i) {
-            sequence = concat(sequence)([i]);
-        }
-        const r = toArray(sequence);
-    },
-    flatToArray: () => {
-        let sequence = [];
-        // 4_000_000 is too much
-        for (let i = 0; i < 2_000_000; ++i) {
-            sequence = flat([sequence, [i]]);
-        }
-        const r = toArray(sequence);
-    },
-    flatNext: () => {
-        let sequence = [];
-        // 4_000_000 is too much
-        for (let i = 0; i < 2_000_000; ++i) {
-            sequence = flat([sequence, [i]]);
-        }
-        const a = next(sequence);
-    },
-    concatFront: () => {
-        let sequence = [];
-        // 20_000_000 is too much
-        for (let i = 0; i < 10_000_000; ++i) {
-            sequence = concat([i])(sequence);
-        }
-        const a = next(sequence);
-    },
-    flatFront: () => {
-        let sequence = [];
-        // 10_000_000 is too much
-        for (let i = 0; i < 5_000_000; ++i) {
-            sequence = flat([[i], sequence]);
-        }
-        const a = next(sequence);
-    },
-    filterMap: () => {
-        // 100_000_000 is too much
-        const n = 50_000_000;
-        const result = toArray(countdown(n));
-        assertEq(result.length, n);
-        const len = length(filterMap(() => null)(result));
-        assertEq(len, 0);
-    },
-    dropWhile: () => {
-        // 50_000_000 is too much
-        const n = 20_000_000;
-        const result = toArray(countdown(n));
-        assertEq(result.length, n);
-        const len = length(dropWhile(() => true)(result));
-        assertEq(len, 0);
-    },
-    reverse: () => {
-        // 10_000_000 is too much
-        const n = 5_000_000;
-        const result = toArray(reverse(countdown(n)));
-        assertEq(result.length, n);
-    }
-});
-export const proof = {
-    stringifyTest,
-    cycle: cycleTest,
-    countdown: countdownTest,
-    flat: flatTest,
-    concat: concatTest,
-    flatMap: flatMapTest,
-    take: takeTest,
-    find: findTest,
-    takeWhile: takeWhileTest,
-    dropWhile: dropWhileTest,
-    drop: dropTest,
-    additionTests,
-    entries: entriesTest,
-    tryFold: tryFoldTest,
-    reverse: reverseTest,
-    zip: zipTest,
-    logic,
-    strictEqual: [
-        () => {
-            const result = equal(strictEqual)([1])([2, 3]);
-            assert(!(result), result);
-        },
-        () => {
-            const result = equal(strictEqual)([1, 3])([1]);
-            assert(!(result), result);
-        },
-        () => {
-            const result = equal(strictEqual)([15, 78])([15, 78]);
-            assert(result, result);
-        },
-        () => {
-            const result = equal(strictEqual)([])([]);
-            assert(result, result);
-        }
-    ],
-    isEmpty: [
-        () => {
-            const result = isEmpty(() => []);
-            assertEq(result, true);
-        },
-        () => {
-            const result = isEmpty(() => [2]);
-            assertEq(result, false);
-        }
-    ],
-    length: () => {
-        assertEq(length([1, 2, 3]), 3);
-        assertEq(length(null), 0);
-        assertEq(length(flat([[1, 3], null, () => [3], concat([12])([4, 89])])), 6);
-    },
-    filterMap: [
-        () => {
-            const result = str(filterMap((x) => x % 2 === 0 ? x * 10 : null)([1, 2, 3, 4, 5]));
-            assertEq(result, '[20,40]');
-        },
-        () => {
-            const result = str(filterMap((x) => x > 3 ? x : null)([1, 2, 3]));
-            assertEq(result, '[]');
-        },
-    ],
-    // stress
-};

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

@@ -1,2 +0,0 @@
-export declare const mapSet: <K, V>(map: ReadonlyMap<K, V>, k: K, v: V) => ReadonlyMap<K, V>;
-export declare const mapDelete: <K, V>(map: ReadonlyMap<K, V>, k: K) => ReadonlyMap<K, V>;

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

@@ -1,22 +0,0 @@
-/**
- * Persistent map operations built on ordered collections.
- *
- * @module
- */
-const concat = (x, y) => ({
-    *[Symbol.iterator]() {
-        yield* x;
-        yield* y;
-    }
-});
-const filter = (i, p) => ({
-    *[Symbol.iterator]() {
-        for (const x of i) {
-            if (p(x)) {
-                yield x;
-            }
-        }
-    }
-});
-export const mapSet = (map, k, v) => new Map(concat(map, [[k, v]]));
-export const mapDelete = (map, k) => new Map(filter(map, ([xk]) => xk !== k));

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

@@ -1,22 +0,0 @@
-import { mapSet, mapDelete } from './module.f.js';
-import { assertEq } from '../../asserts/module.f.js';
-export const proof = {
-    set: () => {
-        const map = mapSet(new Map(), 'a', 'b');
-        assertEq(map.get('a'), 'b', 'error');
-        assertEq(map.size, 1, 'error');
-    },
-    delete: () => {
-        const map = mapDelete(mapSet(new Map(), 'a', 'b'), 'a');
-        assertEq(map.get('a'), undefined, 'error');
-        assertEq(map.size, 0, 'error');
-    },
-    deleteOneOfMany: () => {
-        const m0 = mapSet(new Map(), 'a', 1);
-        const m1 = mapSet(m0, 'b', 2);
-        const result = mapDelete(m1, 'a');
-        assertEq(result.get('b'), 2);
-        assertEq(result.get('a'), undefined);
-        assertEq(result.size, 1);
-    },
-};

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

@@ -1,27 +0,0 @@
-/**
- * Nibble-set operations for compact 4-bit membership tracking.
- *
- * A set of nibbles (values `0..15`) stored as a 16-bit mask in a plain
- * `number`. It implements the same bitmask-as-set algebra as
- * {@link ../byte_set/module.f.ts | `byte_set`}, which tracks all 256 byte
- * values in a `bigint`.
- *
- * **Prefer `byte_set`.** Its 256-value universe covers the common cases and
- * it is the set type used across the codebase. Use `nibble_set` only when
- * the set has to be serialized into JSON: a `NibbleSet` is a `number`, which
- * round-trips through `JSON.stringify`/`JSON.parse` as-is, while a
- * `ByteSet` is a `bigint`, which `JSON.stringify` cannot serialize.
- *
- * @module
- */
-/** A set of nibbles as a 16-bit mask. JSON-serializable. */
-export type NibbleSet = number;
-/** A 4-bit value, `0..15`. */
-export type Nibble = number;
-export declare const empty = 0;
-export declare const universe = 65535;
-export declare const has: (n: Nibble) => (s: NibbleSet) => boolean;
-export declare const set: (n: Nibble) => (s: NibbleSet) => NibbleSet;
-export declare const complement: (n: NibbleSet) => NibbleSet;
-export declare const unset: (n: Nibble) => (s: NibbleSet) => NibbleSet;
-export declare const setRange: (r: readonly [number, number]) => (s: NibbleSet) => NibbleSet;

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

@@ -1,25 +0,0 @@
-/**
- * Nibble-set operations for compact 4-bit membership tracking.
- *
- * A set of nibbles (values `0..15`) stored as a 16-bit mask in a plain
- * `number`. It implements the same bitmask-as-set algebra as
- * {@link ../byte_set/module.f.ts | `byte_set`}, which tracks all 256 byte
- * values in a `bigint`.
- *
- * **Prefer `byte_set`.** Its 256-value universe covers the common cases and
- * it is the set type used across the codebase. Use `nibble_set` only when
- * the set has to be serialized into JSON: a `NibbleSet` is a `number`, which
- * round-trips through `JSON.stringify`/`JSON.parse` as-is, while a
- * `ByteSet` is a `bigint`, which `JSON.stringify` cannot serialize.
- *
- * @module
- */
-export const empty = 0;
-export const universe = 0xFFFF;
-const one = n => 1 << n;
-export const has = n => s => ((s >> n) & 1) === 1;
-export const set = n => s => s | one(n);
-export const complement = s => universe ^ s;
-export const unset = n => s => s & complement(one(n));
-const range = ([a, b]) => one(b - a + 1) - 1 << a;
-export const setRange = r => s => s | range(r);

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

@@ -1,60 +0,0 @@
-import { every, map, countdown } from '../list/module.f.js';
-import { empty, has, set, setRange, unset, universe, complement } from './module.f.js';
-import { assert, assertEq } from '../../asserts/module.f.js';
-export const proof = {
-    has: () => {
-        assert(!(has(0)(empty)), empty);
-        assert(!(has(1)(empty)), empty);
-        assert(!(has(15)(empty)), empty);
-    },
-    set: [
-        () => {
-            const s = set(0)(empty);
-            if (s !== 1) {
-                throw s;
-            }
-            if (!has(0)(s)) {
-                throw s;
-            }
-            assert(!(has(1)(s)), s);
-            assert(!(has(15)(s)), s);
-        },
-        () => {
-            const s = set(15)(empty);
-            assertEq(s, 0x8000);
-            assert(!(has(0)(s)), s);
-            assert(!(has(1)(s)), s);
-            assert(has(15)(s), s);
-        }
-    ],
-    unset: () => [
-        () => {
-            const a = set(0)(empty);
-            const result = unset(0)(a);
-            assertEq(result, 0);
-        },
-        () => {
-            const a = set(15)(empty);
-            const result = unset(15)(a);
-            assertEq(result, 0);
-        }
-    ],
-    setRange: () => {
-        const result = setRange([2, 5])(empty);
-        assertEq(result, 60);
-    },
-    universe: () => {
-        const x = every(map((v) => has(v)(universe))(countdown(16)));
-        assert(x, x);
-    },
-    compliment: {
-        empty: () => {
-            const r = complement(empty);
-            assertEq(r, universe);
-        },
-        universe: () => {
-            const r = complement(universe);
-            assertEq(r, empty);
-        },
-    }
-};

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

@@ -1,22 +0,0 @@
-/**
- * Nominal typing helpers for branded TypeScript types.
- *
- * @module
- */
-/**
- * Nominal type.
- *
- * It doesn't allow `===` between different nominal types.
- * It doesn't allow `<`, `>`, `<=`, `>=` comparisons at all.
- */
-export type Nominal<N extends string, R extends string, B> = symbol & {
-    [k in N]: readonly [R, B];
-};
-/**
- * note: It should compiles into `identity` and no-ops at runtime.
- */
-export declare const asNominal: <N extends string, R extends string, B>(b: B) => Nominal<N, R, B>;
-/**
- * note: It should compiles into `identity` and no-ops at runtime.
- */
-export declare const asBase: <T extends string, R extends string, B>(n: Nominal<T, R, B>) => B;

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

@@ -1,13 +0,0 @@
-/**
- * Nominal typing helpers for branded TypeScript types.
- *
- * @module
- */
-/**
- * note: It should compiles into `identity` and no-ops at runtime.
- */
-export const asNominal = (b) => b;
-/**
- * note: It should compiles into `identity` and no-ops at runtime.
- */
-export const asBase = (n) => n;

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

@@ -1,4 +0,0 @@
-export declare const proof: {
-    pre: () => void;
-    nominal: () => void;
-};

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

@@ -1,48 +0,0 @@
-import { asBase, asNominal } from "./module.f.js";
-import { assert } from '../../asserts/module.f.js';
-export const proof = {
-    pre: () => {
-        const strA = asNominal(7560413859n); // "¢£"
-        const strB = asNominal(7560413860n); // "¢¤"
-        assert(strA !== strB, [strA, strB]);
-        // // TypeScript compilation error.
-        // const x1 = strA > strB
-        //
-        {
-            const a = { value: 1 };
-            const b = { value: 2 };
-            // No Compile-time error
-            if (a < b) { }
-        }
-        {
-            const x = { _brand: 'NoCompare' };
-            // No Error
-            if (x < x) { }
-        }
-        {
-            const a = {};
-            const b = {};
-            // No Error
-            a < b;
-        }
-        {
-            const a = undefined;
-            const b = undefined;
-            // a < b; // TS2469: Operator '<' cannot be applied to type 'symbol'.
-        }
-    },
-    nominal: () => {
-        const userIdA = asNominal(123);
-        const userIdB = asNominal(456);
-        assert(userIdA !== userIdB, [userIdA, userIdB]);
-        const to = asBase;
-        const to2 = asBase;
-        const userId2A = asNominal(123);
-        const userId2B = asNominal(456);
-        assert(userId2A !== userId2B, [userId2A, userId2B]);
-        // assert(userIdA !== userId2A, [userIdA, userId2A]) // compilation error
-        const n1 = to(userIdA);
-        const n2 = to2(userId2A);
-        // const x = to(userId2A) // compilation error
-    }
-};

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

@@ -1,21 +0,0 @@
-import type { Option } from '../option/module.f.ts';
-export type Nullable<T> = T | null;
-export declare const map: <T, R>(f: (value: T) => R) => (value: Nullable<T>) => Nullable<R>;
-export declare const match: <T, R>(f: (_: T) => R) => (none: () => R) => (_: Nullable<T>) => Nullable<R>;
-export declare const toOption: <T>(value: Nullable<T>) => Option<T>;
-/**
- * Normalizes a possibly-`undefined` value into the codebase's `null` convention.
- *
- * The boundary rule between JavaScript hosts (which return `undefined` from
- * property/index lookups) and FunctionalScript (which uses `null` for absence).
- */
-export declare const fromUndefined: <T>(value: T | undefined) => Nullable<T>;
-/**
- * Extracts the value from a `Nullable`, asserting that it is not `null`.
- */
-export declare const unwrap: <T>(value: Nullable<T>) => T;
-/**
- * Lifts a function that signals failure with `null` into one that asserts
- * success instead, unwrapping the result.
- */
-export declare const mapUnwrap: <I, T>(f: (i: I) => Nullable<T>) => import("../function/module.f.ts").Func<I, T>;

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

@@ -1,29 +0,0 @@
-/**
- * Utilities for nullable (`null`/`undefined`) value handling.
- *
- * @module
- */
-import { assert } from '../../asserts/module.f.js';
-import { fn } from '../function/module.f.js';
-export const map = f => value => value === null ? null : f(value);
-export const match = f => none => value => value === null ? none() : f(value);
-export const toOption = (value) => value === null ? [] : [value];
-/**
- * Normalizes a possibly-`undefined` value into the codebase's `null` convention.
- *
- * The boundary rule between JavaScript hosts (which return `undefined` from
- * property/index lookups) and FunctionalScript (which uses `null` for absence).
- */
-export const fromUndefined = (value) => value === undefined ? null : value;
-/**
- * Extracts the value from a `Nullable`, asserting that it is not `null`.
- */
-export const unwrap = (value) => {
-    assert(value !== null);
-    return value;
-};
-/**
- * Lifts a function that signals failure with `null` into one that asserts
- * success instead, unwrapping the result.
- */
-export const mapUnwrap = (f) => fn(f).map(unwrap).result;

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

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

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

@@ -1,29 +0,0 @@
-import { fromUndefined, map, match, toOption } from './module.f.js';
-import { assert, assertEq } from '../../asserts/module.f.js';
-export const proof = [
-    () => {
-        const optionSq = map((v) => v * v);
-        const sq3 = optionSq(3);
-        assertEq(sq3, 9);
-        const sqNull = optionSq(null);
-        assertEq(sqNull, null);
-    },
-    () => {
-        const opt1 = toOption(5);
-        assert(!(opt1.length !== 1 || opt1[0] !== 5), opt1);
-        const opt2 = toOption(null);
-        assertEq(opt2.length, 0, opt2);
-    },
-    () => {
-        const double = match((v) => v * 2)(() => -1);
-        assertEq(double(3), 6);
-        assertEq(double(null), -1);
-    },
-    () => {
-        assertEq(fromUndefined(undefined), null, 0);
-        assertEq(fromUndefined(5), 5, 1);
-        assertEq(fromUndefined(0), 0, 2);
-        assertEq(fromUndefined(null), null, 3);
-        assertEq(fromUndefined(''), '', 4);
-    },
-];

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

@@ -1,16 +0,0 @@
-/**
- * Numeric list reductions (`sum`, `min`, `max`), comparison via `cmp`, and
- * `countOnes` for 32-bit population count using SWAR.
- *
- * @module
- */
-import { type List } from '../list/module.f.ts';
-import { type Sign } from '../function/compare/module.f.ts';
-export declare const sum: (input: List<number>) => number;
-export declare const min: (input: List<number>) => number | null;
-export declare const max: (input: List<number>) => number | null;
-export declare const cmp: (a: number) => (b: number) => Sign;
-/**
- * Count a number of ones in 32 bit number
- */
-export declare const countOnes: (n: number) => number;