functionalscript 0.37.0 → 0.39.0

package/{fs → fjs}/types/btree/set/proof.f.js

@@ -2,7 +2,9 @@ import { set as setSet } from './module.f.js';
 import { cmp } from '../../string/module.f.js';
 import { stringify } from '../../../media/json/module.f.js';
 import { sort } from '../../object/module.f.js';
+import { assertEq } from '../../../asserts/module.f.js';
 const set = (node) => (value) => setSet(cmp(value))(() => value)(node);
+const replace = (node) => (value) => (g) => setSet(cmp(value))(g)(node);
 const jsonStr = stringify(sort);
 const test = [
     () => {
@@ -10,72 +12,56 @@ const test = [
         for (let i = 2; i <= 10; i++)
             _map = set(_map)((i * i).toString());
         const r = jsonStr(_map);
-        if (r !== '[[["1","100"],"16",["25","36"]],"4",[["49"],"64",["81","9"]]]') {
-            throw r;
-        }
+        assertEq(r, '[[["1","100"],"16",["25","36"]],"4",[["49"],"64",["81","9"]]]');
     },
     () => {
         let _map = ['1'];
         for (let i = 2; i <= 11; i++)
             _map = set(_map)((i * i).toString());
         const r = jsonStr(_map);
-        if (r !== '[[["1"],"100",["121"],"16",["25","36"]],"4",[["49"],"64",["81","9"]]]') {
-            throw r;
-        }
+        assertEq(r, '[[["1"],"100",["121"],"16",["25","36"]],"4",[["49"],"64",["81","9"]]]');
     },
     () => {
         let _map = ['1'];
         for (let i = 2; i <= 12; i++)
             _map = set(_map)((i * i).toString());
         const r = jsonStr(_map);
-        if (r !== '[[["1"],"100",["121","144"],"16",["25","36"]],"4",[["49"],"64",["81","9"]]]') {
-            throw r;
-        }
+        assertEq(r, '[[["1"],"100",["121","144"],"16",["25","36"]],"4",[["49"],"64",["81","9"]]]');
     },
     () => {
         let _map = ['1'];
         for (let i = 2; i <= 13; i++)
             _map = set(_map)((i * i).toString());
         const r = jsonStr(_map);
-        if (r !== '[[["1"],"100",["121","144"]],"16",[["169"],"25",["36"]],"4",[["49"],"64",["81","9"]]]') {
-            throw r;
-        }
+        assertEq(r, '[[["1"],"100",["121","144"]],"16",[["169"],"25",["36"]],"4",[["49"],"64",["81","9"]]]');
     },
     () => {
         let _map = ['1'];
         for (let i = 2; i <= 14; i++)
             _map = set(_map)((i * i).toString());
         const r = jsonStr(_map);
-        if (r !== '[[["1"],"100",["121","144"]],"16",[["169","196"],"25",["36"]],"4",[["49"],"64",["81","9"]]]') {
-            throw r;
-        }
+        assertEq(r, '[[["1"],"100",["121","144"]],"16",[["169","196"],"25",["36"]],"4",[["49"],"64",["81","9"]]]');
     },
     () => {
         let _map = ['1'];
         for (let i = 2; i <= 15; i++)
             _map = set(_map)((i * i).toString());
         const r = jsonStr(_map);
-        if (r !== '[[["1"],"100",["121","144"]],"16",[["169"],"196",["225"],"25",["36"]],"4",[["49"],"64",["81","9"]]]') {
-            throw r;
-        }
+        assertEq(r, '[[["1"],"100",["121","144"]],"16",[["169"],"196",["225"],"25",["36"]],"4",[["49"],"64",["81","9"]]]');
     },
     () => {
         let _map = ['1'];
         for (let i = 2; i <= 16; i++)
             _map = set(_map)((i * i).toString());
         const r = jsonStr(_map);
-        if (r !== '[[["1"],"100",["121","144"]],"16",[["169"],"196",["225"],"25",["256","36"]],"4",[["49"],"64",["81","9"]]]') {
-            throw r;
-        }
+        assertEq(r, '[[["1"],"100",["121","144"]],"16",[["169"],"196",["225"],"25",["256","36"]],"4",[["49"],"64",["81","9"]]]');
     },
     () => {
         let _map = ['1'];
         for (let i = 2; i <= 17; i++)
             _map = set(_map)((i * i).toString());
         const r = jsonStr(_map);
-        if (r !== '[[[["1"],"100",["121","144"]],"16",[["169"],"196",["225"]]],"25",[[["256"],"289",["36"]],"4",[["49"],"64",["81","9"]]]]') {
-            throw r;
-        }
+        assertEq(r, '[[[["1"],"100",["121","144"]],"16",[["169"],"196",["225"]]],"25",[[["256"],"289",["36"]],"4",[["49"],"64",["81","9"]]]]');
     },
     () => {
         let _map = ['1'];
@@ -352,6 +338,31 @@ const test = [
                 '[[["529"],"576",["625"]],"64",[["676"],"729",["784"]],"81",[["841"],"9",["900","961"]]]]]') {
             throw r;
         }
+    },
+    // Replacing a key already stored as a branch separator (rather than in a
+    // leaf) exercises the `x.length === 3` and `x.length === 5` arms of the
+    // "replace" case, which plain sequential inserts never reach.
+    () => {
+        let _map = ['1'];
+        for (let i = 2; i <= 10; i++)
+            _map = set(_map)((i * i).toString());
+        // top level is a Branch3 with "4" as its separator (x.length === 3)
+        assertEq(jsonStr(_map), '[[["1","100"],"16",["25","36"]],"4",[["49"],"64",["81","9"]]]');
+        const replaced = replace(_map)('4')(() => '4-updated');
+        assertEq(jsonStr(replaced), '[[["1","100"],"16",["25","36"]],"4-updated",[["49"],"64",["81","9"]]]');
+    },
+    () => {
+        let _map = ['1'];
+        for (let i = 2; i <= 13; i++)
+            _map = set(_map)((i * i).toString());
+        // top level is a Branch5 with "16" as its first separator (i === 1) and
+        // "4" as its second separator (i === 3), so both x.length === 5 replace
+        // arms are reachable from this one fixture.
+        assertEq(jsonStr(_map), '[[["1"],"100",["121","144"]],"16",[["169"],"25",["36"]],"4",[["49"],"64",["81","9"]]]');
+        const replacedFirst = replace(_map)('16')(() => '16-updated');
+        assertEq(jsonStr(replacedFirst), '[[["1"],"100",["121","144"]],"16-updated",[["169"],"25",["36"]],"4",[["49"],"64",["81","9"]]]');
+        const replacedSecond = replace(_map)('4')(() => '4-updated');
+        assertEq(jsonStr(replacedSecond), '[[["1"],"100",["121","144"]],"16",[["169"],"25",["36"]],"4-updated",[["49"],"64",["81","9"]]]');
     }
 ];
 export const proof = test;

package/{fs → fjs}/types/byte_set/proof.f.js

@@ -2,119 +2,78 @@ import { has, empty, set, setRange, unset, universe, complement, toRangeMap } fr
 import { every, countdown, map, toArray } from '../list/module.f.js';
 import { stringify as jsonStringify } from '../../media/json/module.f.js';
 import { sort } from '../object/module.f.js';
+import { assert, assertEq } from '../../asserts/module.f.js';
 const stringify = jsonStringify(sort);
 export const proof = {
     has: [
         () => {
-            if (has(0)(empty)) {
-                throw empty;
-            }
-            if (has(1)(empty)) {
-                throw empty;
-            }
-            if (has(33)(empty)) {
-                throw empty;
-            }
+            assert(!(has(0)(empty)), empty);
+            assert(!(has(1)(empty)), empty);
+            assert(!(has(33)(empty)), empty);
         },
         () => {
             const s = set(0)(empty);
-            if (s !== 1n) {
-                throw s;
-            }
-            if (!has(0)(s)) {
-                throw s;
-            }
-            if (has(1)(s)) {
-                throw s;
-            }
-            if (has(33)(s)) {
-                throw s;
-            }
+            assertEq(s, 1n);
+            assert(has(0)(s), s);
+            assert(!(has(1)(s)), s);
+            assert(!(has(33)(s)), s);
         },
         () => {
             const s = set(33)(empty);
-            if (s !== 8589934592n) {
-                throw s;
-            }
-            if (has(0)(s)) {
-                throw s;
-            }
-            if (has(1)(s)) {
-                throw s;
-            }
-            if (!has(33)(s)) {
-                throw s;
-            }
+            assertEq(s, 8589934592n);
+            assert(!(has(0)(s)), s);
+            assert(!(has(1)(s)), s);
+            assert(has(33)(s), s);
         }
     ],
     setRange: () => {
         const result = setRange([2, 5])(empty);
-        if (result !== 60n) {
-            throw result;
-        }
+        assertEq(result, 60n);
     },
     unset: [
         () => {
             const a = set(0)(empty);
             const result = unset(0)(a);
-            if (result !== 0n) {
-                throw result;
-            }
+            assertEq(result, 0n);
         },
         () => {
             const a = set(255)(empty);
             const result = unset(255)(a);
-            if (result !== 0n) {
-                throw result;
-            }
+            assertEq(result, 0n);
         }
     ],
     universe: () => {
         const x = every(map((v) => has(v)(universe))(countdown(256)));
-        if (!x) {
-            throw x;
-        }
+        assert(x, x);
     },
     compliment: {
         empty: () => {
             const r = complement(empty);
-            if (r !== universe) {
-                throw r;
-            }
+            assertEq(r, universe);
         },
         universe: () => {
             const r = complement(universe);
-            if (r !== empty) {
-                throw r;
-            }
+            assertEq(r, empty);
         },
     },
     toRangeMap: [
         () => {
             const result = stringify(toArray(toRangeMap(empty)('a')));
-            if (result !== '[]') {
-                throw result;
-            }
+            assertEq(result, '[]');
         },
         () => {
             const s = set(0)(empty);
             const result = stringify(toArray(toRangeMap(s)('a')));
-            if (result !== '[[["a"],0]]') {
-                throw result;
-            }
+            assertEq(result, '[[["a"],0]]');
         },
         () => {
             const s = setRange([1, 2])(empty);
             const result = stringify(toArray(toRangeMap(s)('a')));
-            if (result !== '[[[],0],[["a"],2]]') {
-                throw result;
-            }
+            assertEq(result, '[[[],0],[["a"],2]]');
         },
         () => {
             const result = stringify(toArray(toRangeMap(universe)('a')));
-            if (result !== '[[["a"],255]]') {
-                throw result;
-            }
+            assertEq(result, '[[["a"],255]]');
         },
     ]
 };

package/{fs → fjs}/types/function/compare/proof.f.js

@@ -1,31 +1,24 @@
 import { cmp, min, max } from './module.f.js';
+import { assertEq } from '../../../asserts/module.f.js';
 export const proof = () => {
     {
         const result = cmp(true)(false);
-        if (result !== 1) {
-            throw result;
-        }
+        assertEq(result, 1);
         const _ = true < false;
     }
     {
         const result = cmp(1)(2);
-        if (result !== -1) {
-            throw result;
-        }
+        assertEq(result, -1);
         const _ = 1 < 2;
     }
     {
         const result = cmp(2n)(-10n);
-        if (result !== 1) {
-            throw result;
-        }
+        assertEq(result, 1);
         const _ = 2n < -10n;
     }
     {
         const result = cmp("hello")("hello");
-        if (result !== 0) {
-            throw result;
-        }
+        assertEq(result, 0);
         const _ = "hello" < "hello";
     }
     {
@@ -38,33 +31,17 @@ export const proof = () => {
         // const f = (a: number, b: string|number) => cmp(a)(b) // compilation error
     }
     {
-        if (min(3)(5) !== 3) {
-            throw 'min(3)(5)';
-        }
-        if (min(7)(2) !== 2) {
-            throw 'min(7)(2)';
-        }
-        if (min(3n)(13n) !== 3n) {
-            throw 'min(3n)(13n)';
-        }
-        if (min("a")("b") !== "a") {
-            throw 'min("a")("b")';
-        }
+        assertEq(min(3)(5), 3, 'min(3)(5)');
+        assertEq(min(7)(2), 2, 'min(7)(2)');
+        assertEq(min(3n)(13n), 3n, 'min(3n)(13n)');
+        assertEq(min("a")("b"), "a", 'min("a")("b")');
         // const _ = min(1)("a") // compilation error
     }
     {
-        if (max(3)(5) !== 5) {
-            throw 'max(3)(5)';
-        }
-        if (max(7)(2) !== 7) {
-            throw 'max(7)(2)';
-        }
-        if (max(3n)(13n) !== 13n) {
-            throw 'max(3n)(13n)';
-        }
-        if (max("a")("b") !== "b") {
-            throw 'max("a")("b")';
-        }
+        assertEq(max(3)(5), 5, 'max(3)(5)');
+        assertEq(max(7)(2), 7, 'max(7)(2)');
+        assertEq(max(3n)(13n), 13n, 'max(3n)(13n)');
+        assertEq(max("a")("b"), "b", 'max("a")("b")');
         // const _ = max(1)("a") // compilation error
     }
 };

package/{fs → fjs}/types/function/operator/proof.f.js

@@ -1,84 +1,53 @@
+import { assert, assertEq } from '../../../asserts/module.f.js';
 import { join, concat, logicalNot, strictEqual, addition, increment, counter, stateScanToScan, foldToScan, reduceToScan, } from './module.f.js';
 const joinTest = () => {
     const result = join(', ')('world')('hello');
-    if (result !== 'hello, world') {
-        throw result;
-    }
+    assertEq(result, 'hello, world');
 };
 const concatTest = () => {
     const result = concat('world')('hello');
-    if (result !== 'helloworld') {
-        throw result;
-    }
+    assertEq(result, 'helloworld');
 };
 const logicalNotTest = () => {
-    if (logicalNot(true) !== false) {
-        throw 'expected false';
-    }
-    if (logicalNot(false) !== true) {
-        throw 'expected true';
-    }
+    assertEq(logicalNot(true), false, 'expected false');
+    assertEq(logicalNot(false), true, 'expected true');
 };
 const strictEqualTest = () => {
-    if (!strictEqual(1)(1)) {
-        throw 'expected true';
-    }
-    if (strictEqual(1)(2)) {
-        throw 'expected false';
-    }
+    assert(strictEqual(1)(1), 'expected true');
+    assert(!(strictEqual(1)(2)), 'expected false');
 };
 const additionTest = () => {
     const result = addition(3)(4);
-    if (result !== 7) {
-        throw result;
-    }
+    assertEq(result, 7);
 };
 const incrementTest = () => {
-    if (increment(4) !== 5) {
-        throw 'increment(4)';
-    }
-    if (increment(0) !== 1) {
-        throw 'increment(0)';
-    }
+    assertEq(increment(4), 5, 'increment(4)');
+    assertEq(increment(0), 1, 'increment(0)');
 };
 const foldToScanTest = () => {
     const scan = foldToScan(addition)(0);
     const [v1, scan2] = scan(3);
-    if (v1 !== 3) {
-        throw v1;
-    }
+    assertEq(v1, 3);
     const [v2] = scan2(4);
-    if (v2 !== 7) {
-        throw v2;
-    }
+    assertEq(v2, 7);
 };
 const reduceToScanTest = () => {
     const scan = reduceToScan(addition);
     const [v0, scan2] = scan(10);
-    if (v0 !== 10) {
-        throw v0;
-    }
+    assertEq(v0, 10);
     const [v1] = scan2(5);
-    if (v1 !== 15) {
-        throw v1;
-    }
+    assertEq(v1, 15);
 };
 const counterTest = () => {
     const fn = counter();
-    if (fn(4) !== 5) {
-        throw 'counter() returned wrong function';
-    }
+    assertEq(fn(4), 5, 'counter() returned wrong function');
 };
 const stateScanToScanTest = () => {
     const op = (input, state) => [input + state, input + state];
     const scan = stateScanToScan(op)(0);
     const [v1, scan2] = scan(3);
-    if (v1 !== 3) {
-        throw v1;
-    }
+    assertEq(v1, 3);
     const [v2] = scan2(4);
-    if (v2 !== 7) {
-        throw v2;
-    }
+    assertEq(v2, 7);
 };
 export const proof = { joinTest, concatTest, logicalNotTest, strictEqualTest, additionTest, incrementTest, counterTest, stateScanToScanTest, foldToScanTest, reduceToScanTest };

package/{fs → fjs}/types/function/proof.f.js

@@ -1,11 +1,10 @@
 import { fn } from './module.f.js';
+import { assertEq } from '../../asserts/module.f.js';
 export const proof = () => {
     const f = x => [x];
     const g = ([x]) => [x.length];
     const w = ([x]) => x;
     const r = fn(f).map(g).map(w).result;
     const result = r('hello');
-    if (result !== 5) {
-        throw r;
-    }
+    assertEq(result, 5, r);
 };

package/{fs → fjs}/types/list/module.f.d.ts

@@ -1,3 +1,4 @@
+import type { Nullable } from '../nullable/module.f.ts';
 import { type Scan, type StateScan, type Fold, type Reduce, type Equal } from '../function/operator/module.f.ts';
 export type List<T> = NotLazy<T> | Thunk<T>;
 type NotLazy<T> = Result<T> | Concat<T> | readonly T[];
@@ -44,6 +45,26 @@ export declare const stateScan: <I, S, O>(op: StateScan<I, S, O>) => (init: S) =
 export declare const foldScan: <I, O>(op: Fold<I, O>) => (init: O) => (input: List<I>) => Thunk<O>;
 export declare const fold: <I, O>(op: Fold<I, O>) => (init: O) => (input: List<I>) => O;
 export declare const reduce: <T>(op: Reduce<T>) => <D>(def: D) => (input: List<T>) => D | T;
+/**
+ * A fold that can bail out early, packaged as plain data.
+ *
+ * `init` is the starting state, `update` advances the state by one item and
+ * returns `null` to abort the whole fold, and `end` finalizes the surviving
+ * state into a result. Keeping the three parts together lets `tryFold` drive
+ * any short-circuiting accumulation without knowing its domain.
+ */
+export type Accumulator<I, T, R> = {
+    readonly init: T;
+    readonly update: (i: I, state: T) => Nullable<T>;
+    readonly end: (state: T) => R;
+};
+/**
+ * Folds `input` with an {@link Accumulator}, short-circuiting to `null` the
+ * moment `update` rejects an item; otherwise finalizes with `end`. This is the
+ * list-level `try*` sibling of {@link fold} for accumulations that can fail
+ * partway through (see the `try*`/`Nullable` convention in `AGENTS.md`).
+ */
+export declare const tryFold: <I, T, R>({ init, update, end }: Accumulator<I, T, R>) => (input: List<I>) => Nullable<R>;
 export declare const length: <T>(input: List<T>) => number;
 export type Entry<T> = readonly [number, T];
 export declare const entries: <T>(input: List<T>) => Thunk<Entry<T>>;

package/{fs → fjs}/types/list/module.f.js

@@ -127,6 +127,23 @@ export const stateScan = op => compose(stateScanToScan(op))(scan);
 export const foldScan = op => compose(foldToScan(op))(scan);
 export const fold = op => init => compose(foldScan(op)(init))(last(init));
 export const reduce = op => def => compose(scan(reduceToScan(op)))(last(def));
+/**
+ * Folds `input` with an {@link Accumulator}, short-circuiting to `null` the
+ * moment `update` rejects an item; otherwise finalizes with `end`. This is the
+ * list-level `try*` sibling of {@link fold} for accumulations that can fail
+ * partway through (see the `try*`/`Nullable` convention in `AGENTS.md`).
+ */
+export const tryFold = ({ init, update, end }) => (input) => {
+    let state = init;
+    for (const i of iterable(input)) {
+        const candidate = update(i, state);
+        if (candidate === null) {
+            return null;
+        }
+        state = candidate;
+    }
+    return end(state);
+};
 const lengthList = list => () => {
     const notLazy = trampoline(list);
     if (notLazy === null) {

package/{fs → fjs}/types/list/proof.f.d.ts

@@ -19,6 +19,7 @@ export declare const proof: {
     drop: (() => void)[];
     additionTests: (() => void)[];
     entries: (() => void)[];
+    tryFold: readonly [() => void, () => void, () => void];
     reverse: (() => void)[];
     zip: (() => void)[];
     logic: typeof logic;