functionalscript 0.37.0 → 0.38.0

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

@@ -86,7 +86,7 @@ const nodeSet = (c) => (g) => (node) => {
                 // insert
                 const value = g(null);
                 // TODO: remove after TSGO fix the regression.
-                const _xl = x.length;
+                // const _xl: 1|2 = x.length
                 switch (x.length) {
                     case 1: {
                         return [[x[0], value]];
@@ -96,12 +96,13 @@ const nodeSet = (c) => (g) => (node) => {
                     }
                 }
                 // TODO: remove after TSGO fix the regression.
+                // See https://github.com/microsoft/typescript-go/issues/4613
                 throw 'unreachable';
             }
             case 3: {
                 // replace
                 // TODO: remove after TSGO fix the regression.
-                const _xl = x.length;
+                // const _xl: 2|5 = x.length
                 switch (x.length) {
                     case 2: {
                         return [[x[0], g(x[1])]];
@@ -115,6 +116,8 @@ const nodeSet = (c) => (g) => (node) => {
             }
             case 4: {
                 // insert
+                // TODO: remove after TSGO fix the regression.
+                // const _xl: 2 = x.length
                 const [v0, v1] = x;
                 return [[v0], v1, [g(null)]];
             }

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);
 };