functionalscript 0.36.0 → 0.38.0

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

@@ -1,8 +1,10 @@
-import { set as setSet } from "./module.f.js";
-import { cmp } from "../../string/module.f.js";
-import { stringify } from "../../../json/module.f.js";
-import { sort } from "../../object/module.f.js";
+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/module.f.js

@@ -3,8 +3,8 @@
  *
  * @module
  */
-import { compose } from "../function/module.f.js";
-import { reverse, countdown, flat, map } from "../list/module.f.js";
+import { compose } from '../function/module.f.js';
+import { reverse, countdown, flat, map } from '../list/module.f.js';
 export const has = n => s => ((s >> BigInt(n)) & 1n) === 1n;
 // create a set
 export const empty = 0n;

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

@@ -0,0 +1,79 @@
+import { has, empty, set, setRange, unset, universe, complement, toRangeMap } from './module.f.js';
+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: [
+        () => {
+            assert(!(has(0)(empty)), empty);
+            assert(!(has(1)(empty)), empty);
+            assert(!(has(33)(empty)), empty);
+        },
+        () => {
+            const s = set(0)(empty);
+            assertEq(s, 1n);
+            assert(has(0)(s), s);
+            assert(!(has(1)(s)), s);
+            assert(!(has(33)(s)), s);
+        },
+        () => {
+            const s = set(33)(empty);
+            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);
+        assertEq(result, 60n);
+    },
+    unset: [
+        () => {
+            const a = set(0)(empty);
+            const result = unset(0)(a);
+            assertEq(result, 0n);
+        },
+        () => {
+            const a = set(255)(empty);
+            const result = unset(255)(a);
+            assertEq(result, 0n);
+        }
+    ],
+    universe: () => {
+        const x = every(map((v) => has(v)(universe))(countdown(256)));
+        assert(x, x);
+    },
+    compliment: {
+        empty: () => {
+            const r = complement(empty);
+            assertEq(r, universe);
+        },
+        universe: () => {
+            const r = complement(universe);
+            assertEq(r, empty);
+        },
+    },
+    toRangeMap: [
+        () => {
+            const result = stringify(toArray(toRangeMap(empty)('a')));
+            assertEq(result, '[]');
+        },
+        () => {
+            const s = set(0)(empty);
+            const result = stringify(toArray(toRangeMap(s)('a')));
+            assertEq(result, '[[["a"],0]]');
+        },
+        () => {
+            const s = setRange([1, 2])(empty);
+            const result = stringify(toArray(toRangeMap(s)('a')));
+            assertEq(result, '[[[],0],[["a"],2]]');
+        },
+        () => {
+            const result = stringify(toArray(toRangeMap(universe)('a')));
+            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 { 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/fjs/types/function/operator/proof.f.d.ts

@@ -0,0 +1,23 @@
+declare const joinTest: () => void;
+declare const concatTest: () => void;
+declare const logicalNotTest: () => void;
+declare const strictEqualTest: () => void;
+declare const additionTest: () => void;
+declare const incrementTest: () => void;
+declare const foldToScanTest: () => void;
+declare const reduceToScanTest: () => void;
+declare const counterTest: () => void;
+declare const stateScanToScanTest: () => void;
+export declare const proof: {
+    joinTest: typeof joinTest;
+    concatTest: typeof concatTest;
+    logicalNotTest: typeof logicalNotTest;
+    strictEqualTest: typeof strictEqualTest;
+    additionTest: typeof additionTest;
+    incrementTest: typeof incrementTest;
+    counterTest: typeof counterTest;
+    stateScanToScanTest: typeof stateScanToScanTest;
+    foldToScanTest: typeof foldToScanTest;
+    reduceToScanTest: typeof reduceToScanTest;
+};
+export {};

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

@@ -1,84 +1,53 @@
-import { join, concat, logicalNot, strictEqual, addition, increment, counter, stateScanToScan, foldToScan, reduceToScan, } from "./module.f.js";
+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 { 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.js

@@ -3,8 +3,8 @@
  *
  * @module
  */
-import { identity, fn, compose } from "../function/module.f.js";
-import { addition, logicalNot, strictEqual, stateScanToScan, foldToScan, reduceToScan, } from "../function/operator/module.f.js";
+import { identity, fn, compose } from '../function/module.f.js';
+import { addition, logicalNot, strictEqual, stateScanToScan, foldToScan, reduceToScan, } from '../function/operator/module.f.js';
 export const fromArrayLike = (array) => {
     const at = (i) => i < array.length ? { first: array[i], tail: () => at(i + 1) } : null;
     return at(0);

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

@@ -0,0 +1,30 @@
+declare const stringifyTest: () => void;
+declare const countdownTest: () => void;
+declare const flatTest: () => void;
+declare const concatTest: () => void;
+declare const flatMapTest: () => void;
+declare const dropWhileTest: () => void;
+declare const logic: () => (() => void)[];
+export declare const proof: {
+    stringifyTest: typeof stringifyTest;
+    cycle: (() => void)[];
+    countdown: typeof countdownTest;
+    flat: typeof flatTest;
+    concat: typeof concatTest;
+    flatMap: typeof flatMapTest;
+    take: (() => void)[];
+    find: (() => void)[];
+    takeWhile: (() => void)[];
+    dropWhile: typeof dropWhileTest;
+    drop: (() => void)[];
+    additionTests: (() => void)[];
+    entries: (() => void)[];
+    reverse: (() => void)[];
+    zip: (() => void)[];
+    logic: typeof logic;
+    strictEqual: (() => void)[];
+    isEmpty: (() => void)[];
+    length: () => void;
+    filterMap: (() => void)[];
+};
+export {};