functionalscript 0.37.0 → 0.38.0

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

@@ -1,21 +1,14 @@
 import { parse } from './module.f.js';
 import { boolean, number, string, bigint, unknown, array, record, or, option } from '../module.f.js';
-const assertOk = ([k]) => { if (k !== 'ok') {
-    throw 'expected ok';
-} };
-const assertError = ([k]) => { if (k !== 'error') {
-    throw 'expected error';
-} };
+import { assert, assertEq } from '../../../asserts/module.f.js';
+const assertOk = ([k]) => { assertEq(k, 'ok', 'expected ok'); };
+const assertError = ([k]) => { assertEq(k, 'error', 'expected error'); };
 const unwrap = (r) => {
-    if (r[0] !== 'ok') {
-        throw 'expected ok';
-    }
+    assert(r[0] === 'ok', 'expected ok');
     return r[1];
 };
 const assertErrorPath = (expected) => (r) => {
-    if (r[0] !== 'error') {
-        throw 'expected error';
-    }
+    assert(r[0] === 'error', 'expected error');
     const e = r[1];
     if (e.path.length !== expected.length) {
         throw `path length ${e.path.length} != ${expected.length}`;
@@ -207,9 +200,7 @@ export const proof = {
         freshArray: () => {
             const input = [1, 2, 3];
             const out = unwrap(parse(array(number))(input));
-            if (out === input) {
-                throw 'expected a fresh array';
-            }
+            assert(out !== input, 'expected a fresh array');
             assertDeepEqual(out, [1, 2, 3]);
         },
         error: () => {
@@ -236,9 +227,7 @@ export const proof = {
         freshRecord: () => {
             const input = { a: 1, b: 2 };
             const out = unwrap(parse(record(number))(input));
-            if (out === input) {
-                throw 'expected a fresh record';
-            }
+            assert(out !== input, 'expected a fresh record');
             assertDeepEqual(out, { a: 1, b: 2 });
         },
         error: () => {

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

@@ -11,9 +11,15 @@ export type Primitive = null | boolean | number | string | undefined | bigint;
  * The TypeScript type that rtti's `unknown` schema validates — any value that
  * an rtti schema can represent: a primitive, an array, or an object.
  *
- * Currently equivalent to `djs.Unknown`, but defined here to keep `rtti` free
- * of `djs` dependencies. May be extended to include functions or other
- * non-JSON-primitives in the future.
+ * This is the single source of truth for the rtti value domain: every rtti
+ * module (`common`, `validate`, `parse`, …) imports `Unknown`/`Primitive`
+ * from here, not from `djs`, keeping `rtti` free of a `djs` dependency (djs
+ * depends on rtti, not the other way around).
+ *
+ * The relationship to djs is a subset one — `djs.Unknown ⊆ rtti.Unknown` — not
+ * equality: the two happen to coincide today, but `rtti.Unknown` may widen to
+ * admit values djs cannot represent (e.g. functions) without djs following.
+ * Do not re-point rtti imports at `djs.Unknown` on the assumption they match.
  */
 export type Unknown = Primitive | Array | Object;
 /** A read-only array of {@link Unknown} values. */
@@ -54,7 +60,7 @@ export type StructTs<T extends Struct> = (keyof OptionalFields<T> extends never
  *
  * **Recursive schemas and TS2589:** when a schema is self-referential, `StructTs` would
  * expand infinitely and TypeScript raises TS2589. Break the cycle by annotating the
- * schema value with `Phantom<typeof myThunk, MyType>` from `fs/types/phantom/module.f.ts`.
+ * schema value with `Phantom<typeof myThunk, MyType>` from `fjs/types/phantom/module.f.ts`.
  * `Ts<>` detects the phantom key and returns `MyType` directly without recursing:
  *
  * ```ts

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

@@ -1,8 +1,10 @@
 import {} from '../module.f.js';
 import { ok } from '../../result/module.f.js';
-import { constPrimitiveValidate, isArray, isObject, prependPath, primitive0Validate, verror, visit, } from '../common/module.f.js';
+import { constPrimitiveValidate, eachEntry, isArray, isObject, orVisit, primitive0Validate, verror, visit, } from '../common/module.f.js';
 export { constPrimitiveValidate, prependPath, primitive0Validate, verror, } from '../common/module.f.js';
 const { entries } = Object;
+/** `validate` has nothing to collect from a successful entry — only pass/fail matters. */
+const noAccumulate = () => undefined;
 /**
  * Builds a validator for `array` or `record` schemas.
  * The inner item validator is instantiated lazily (only when the container is
@@ -19,15 +21,10 @@ const containerValidate = (isContainer) => (item) => value => {
     // Note: we shouldn't instantiate `itemValidate` until we make sure `entries` is not empty.
     //       Otherwise, we can get infinite recursion on empty arrays and objects
     const itemValidate = validate(item);
-    for (const [k, v] of e) {
-        const r = itemValidate(v);
-        if (r[0] === 'error') {
-            return prependPath(k, r);
-        }
-    }
+    const r = eachEntry(e, (_k, v) => itemValidate(v), undefined, noAccumulate);
     // `value` is Container<K>, but Ts<Info1<K,I>> = readonly Ts<I>[] | Record<string,Ts<I>>.
     // TypeScript can't narrow the container's element types through the validation loop.
-    return ok(value);
+    return r[0] === 'error' ? r : ok(value);
 };
 const arrayValidate = containerValidate(isArray);
 const recordValidate = containerValidate(isObject);
@@ -40,32 +37,14 @@ const constContainerValidate = (isContainer, getItem) => (rtti) => value => {
     if (!isContainer(value)) {
         return verror('unexpected value');
     }
-    for (const [k, v] of Object.entries(rtti)) {
-        const item = getItem(value, k);
-        const r = validate(v)(item);
-        if (r[0] === 'error') {
-            return prependPath(k, r);
-        }
-    }
+    const r = eachEntry(Object.entries(rtti), (k, v) => validate(v)(getItem(value, k)), undefined, noAccumulate);
     // `value` is C (Unknown container), but Ts<T> for T extends Tuple|Struct is not
     // structurally equivalent to C — TypeScript can't narrow element types through the loop.
-    return ok(value);
+    return r[0] === 'error' ? r : ok(value);
 };
 const tupleValidate = constContainerValidate(isArray, (value, k) => value[Number(k)]);
 const structValidate = constContainerValidate(isObject, (value, k) => value[k]);
-const orValidate = (rtti) => {
-    const all = rtti.map(r => validate(r));
-    return value => {
-        for (const i of all) {
-            // `i` is Validate<Type>; calling without cast forces Ts<Type> evaluation → TS2589.
-            const r = i(value);
-            if (r[0] === 'ok') {
-                return r;
-            }
-        }
-        return verror('no match');
-    };
-};
+const orValidate = (rtti) => orVisit(validate)(rtti);
 /**
  * Creates a validator function for the given RTTI schema.
  *

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

@@ -1,15 +1,10 @@
 import { validate } from './module.f.js';
 import { boolean, number, string, bigint, unknown, array, record, or, option } from '../module.f.js';
-const assertOk = ([k]) => { if (k !== 'ok') {
-    throw 'expected ok';
-} };
-const assertError = ([k]) => { if (k !== 'error') {
-    throw 'expected error';
-} };
+import { assert, assertEq } from '../../../asserts/module.f.js';
+const assertOk = ([k]) => { assertEq(k, 'ok', 'expected ok'); };
+const assertError = ([k]) => { assertEq(k, 'error', 'expected error'); };
 const assertErrorPath = (expected) => (r) => {
-    if (r[0] !== 'error') {
-        throw 'expected error';
-    }
+    assert(r[0] === 'error', 'expected error');
     const e = r[1];
     if (e.path.length !== expected.length) {
         throw `path length ${e.path.length} != ${expected.length}`;

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

@@ -4,56 +4,43 @@ import { sort } from '../object/module.f.js';
 import { toArray, countdown, length } from '../list/module.f.js';
 import { flip } from '../function/module.f.js';
 import { cmp } from '../number/module.f.js';
+import { assert, assertEq } from '../../asserts/module.f.js';
 const str = stringify(sort);
 const reverseCmp = flip(cmp);
 export const proof = {
     sortedMergre: [
         () => {
             const result = str(toArray(merge(cmp)([2, 3, 4])([1, 3, 5])));
-            if (result !== '[1,2,3,4,5]') {
-                throw result;
-            }
+            assertEq(result, '[1,2,3,4,5]');
         },
         () => {
             const result = str(toArray(merge(cmp)([1, 2, 3])([])));
-            if (result !== '[1,2,3]') {
-                throw result;
-            }
+            assertEq(result, '[1,2,3]');
         },
         () => {
             const n = 10_000;
             const list = countdown(n);
             const result = merge(reverseCmp)(list)(list);
             const len = length(result);
-            if (len != n) {
-                throw result;
-            }
+            assert(len == n, result);
         }
     ],
     find: [
         () => {
             const result = find(cmp)(0)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
-            if (result !== 0) {
-                throw result;
-            }
+            assertEq(result, 0);
         },
         () => {
             const result = find(cmp)(3)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
-            if (result !== null) {
-                throw result;
-            }
+            assertEq(result, null);
         },
         () => {
             const result = find(cmp)(77)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
-            if (result !== null) {
-                throw result;
-            }
+            assertEq(result, null);
         },
         () => {
             const result = find(cmp)(80)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
-            if (result !== 80) {
-                throw result;
-            }
+            assertEq(result, 80);
         }
     ]
 };

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

@@ -4,6 +4,7 @@ import { sort } from '../object/module.f.js';
 import { toArray, countdown, length } from '../list/module.f.js';
 import { flip } from '../function/module.f.js';
 import { cmp } from '../number/module.f.js';
+import { assert, assertEq } from '../../asserts/module.f.js';
 const str = a => stringify(sort)(a);
 const reverseCmp = flip(cmp);
 export const proof = {
@@ -12,81 +13,55 @@ export const proof = {
         const setA = [1, 3, 5];
         const setB = [3, 4, 5];
         const unionSet = union(cmp)(setA)(setB); // [1, 3, 4, 5]
-        if (str(unionSet) !== '[1,3,4,5]') {
-            throw 0;
-        }
+        assertEq(str(unionSet), '[1,3,4,5]', 0);
         const intersectionSet = intersect(cmp)(setA)(setB); // [3, 5]
-        if (str(intersectionSet) !== '[3,5]') {
-            throw 1;
-        }
-        if (!has(cmp)(3)(setA)) {
-            throw 2;
-        }
-        if (has(cmp)(2)(setA)) {
-            throw 3;
-        }
+        assertEq(str(intersectionSet), '[3,5]', 1);
+        assert(has(cmp)(3)(setA), 2);
+        assert(!(has(cmp)(2)(setA)), 3);
     },
     union: [
         () => {
             const result = str(toArray(union(cmp)([2, 3, 4])([1, 3, 5])));
-            if (result !== '[1,2,3,4,5]') {
-                throw result;
-            }
+            assertEq(result, '[1,2,3,4,5]');
         },
         () => {
             const result = str(toArray(union(cmp)([1, 2, 3])([])));
-            if (result !== '[1,2,3]') {
-                throw result;
-            }
+            assertEq(result, '[1,2,3]');
         },
         () => {
             const n = 10_000;
             const sortedSet = toArray(countdown(n));
             const result = union(reverseCmp)(sortedSet)(sortedSet);
             const len = length(result);
-            if (len != n) {
-                throw result;
-            }
+            assert(len == n, result);
         }
     ],
     intersect: [
         () => {
             const result = str(toArray(intersect(cmp)([2, 3, 4])([1, 3, 5])));
-            if (result !== '[3]') {
-                throw result;
-            }
+            assertEq(result, '[3]');
         },
         () => {
             const result = str(toArray(intersect(cmp)([1, 2, 3])([])));
-            if (result !== '[]') {
-                throw result;
-            }
+            assertEq(result, '[]');
         }
     ],
     has: [
         () => {
             const result = has(cmp)(0)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
-            if (!result) {
-                throw result;
-            }
+            assert(result, result);
         },
         () => {
             const result = has(cmp)(3)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
-            if (result) {
-                throw result;
-            }
+            assert(!(result), result);
         },
         () => {
             const result = has(cmp)(77)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
-            if (result) {
-                throw result;
-            }
+            assert(!(result), result);
         },
         () => {
             const result = has(cmp)(80)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
-            if (!result) {
-                throw result;
-            }
+            assert(result, result);
         }
     ]
 };

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

@@ -0,0 +1,77 @@
+import { join, concat, repeat, cmp, splitAt } from './module.f.js';
+import { repeat as repeatList } from '../list/module.f.js';
+import { assert, assertEq } from '../../asserts/module.f.js';
+export const proof = {
+    example: () => {
+        const words = ['hello', 'world'];
+        assertEq(join(' ')(words), 'hello world', 0);
+        assertEq(concat(words), 'helloworld', 1);
+        assertEq(repeat('abc')(3), 'abcabcabc', 2);
+        assertEq(cmp('apple')('banana'), -1, 3);
+    },
+    join: {
+        0: () => {
+            const result = join('/')([]);
+            assertEq(result, '');
+        },
+        1: () => {
+            const result = join('/')(['']);
+            assertEq(result, '');
+        },
+        3: () => {
+            const result = join(' ')(['hello', 'world', '!']);
+            assertEq(result, 'hello world !');
+        }
+    },
+    concat: () => {
+        const result = concat(['hello', 'world']);
+        assertEq(result, 'helloworld');
+    },
+    repeatList: {
+        0: () => {
+            const s = join('.')(repeatList('x')(0));
+            assert(s == '', s);
+        },
+        5: () => {
+            const s = join('.')(repeatList('x')(5));
+            assert(s == 'x.x.x.x.x', s);
+        }
+    },
+    repeat: () => {
+        const s = repeat('x')(5);
+        if (s != 'xxxxx') {
+            throw s;
+        }
+    },
+    cmp: () => {
+        const result = cmp('3')('4');
+        assertEq(result, -1);
+    },
+    splitAt: {
+        middle: () => {
+            const [a, b] = splitAt(3)('hello');
+            assertEq(a, 'hel');
+            assertEq(b, 'lo');
+        },
+        zero: () => {
+            const [a, b] = splitAt(0)('hello');
+            assertEq(a, '');
+            assertEq(b, 'hello');
+        },
+        full: () => {
+            const [a, b] = splitAt(5)('hello');
+            assertEq(a, 'hello');
+            assertEq(b, '');
+        },
+        beyond: () => {
+            const [a, b] = splitAt(10)('hello');
+            assertEq(a, 'hello');
+            assertEq(b, '');
+        },
+        empty: () => {
+            const [a, b] = splitAt(0)('');
+            assertEq(a, '');
+            assertEq(b, '');
+        },
+    }
+};

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

@@ -0,0 +1,43 @@
+import { contains, fromValues, remove, set } from './module.f.js';
+import { assert, assertEq } from '../../asserts/module.f.js';
+export const proof = {
+    example: () => {
+        let mySet = fromValues(['apple', 'banana', 'cherry']);
+        assert(contains('banana')(mySet), '1');
+        assert(!(contains('date')(mySet)), '2');
+        mySet = set('date')(mySet);
+        assert(contains('date')(mySet), '3');
+        mySet = remove('banana')(mySet);
+        assert(!(contains('banana')(mySet)), '4');
+    },
+    contains: () => {
+        const r = set('hello')(null);
+        assert(contains('hello')(r), r);
+        assert(!(contains('hello1')(r)), r);
+    },
+    remove: () => {
+        let r = set('hello')(null);
+        r = set('world')(r);
+        r = set('HELLO')(r);
+        r = set('WORLD!')(r);
+        assert(contains('hello')(r), r);
+        assert(!(contains('hello1')(r)), r);
+        assert(contains('HELLO')(r), r);
+        assert(!(contains('WORLD')(r)), r);
+        assert(contains('world')(r), r);
+        assert(!(contains('world!')(r)), r);
+        assert(contains('WORLD!')(r), r);
+        //
+        r = remove('hello')(r);
+        assert(!(contains('hello')(r)), r);
+        assert(contains('world')(r), r);
+        r = remove('world')(r);
+        assert(!(contains('world')(r)), r);
+        assert(contains('HELLO')(r), r);
+        r = remove('HELLO')(r);
+        assert(!(contains('HELLO')(r)), r);
+        assert(contains('WORLD!')(r), r);
+        r = remove('WORLD!')(r);
+        assertEq(r, null);
+    }
+};

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

@@ -1,71 +1,50 @@
 import { printer, primitive, union } from './module.f.js';
+import { assertEq } from '../../asserts/module.f.js';
 const ro = printer();
 const mut = printer(true);
 export const primitiveNull = () => {
     const r = primitive(null);
-    if (r !== 'null') {
-        throw r;
-    }
+    assertEq(r, 'null');
 };
 export const primitiveBigint = () => {
     const r = primitive(42n);
-    if (r !== '42n') {
-        throw r;
-    }
+    assertEq(r, '42n');
 };
 export const primitiveString = () => {
     const r = primitive('hello');
-    if (r !== '"hello"') {
-        throw r;
-    }
+    assertEq(r, '"hello"');
 };
 export const primitiveNumberFinite = () => {
     const r = primitive(3.14);
-    if (r !== '3.14') {
-        throw r;
-    }
+    assertEq(r, '3.14');
 };
 export const primitiveNumberInfinite = () => {
     const r = primitive(Infinity);
-    if (r !== 'number') {
-        throw r;
-    }
+    assertEq(r, 'number');
 };
 export const primitiveUndefined = () => {
     const r = primitive(undefined);
-    if (r !== 'undefined') {
-        throw r;
-    }
+    assertEq(r, 'undefined');
 };
 export const primitiveBoolean = () => {
     const r = primitive(true);
-    if (r !== 'true') {
-        throw r;
-    }
+    assertEq(r, 'true');
 };
 export const unionEmpty = () => {
     const r = union([]);
-    if (r !== 'never') {
-        throw r;
-    }
+    assertEq(r, 'never');
 };
 export const unionSingle = () => {
     const r = union(['string']);
-    if (r !== 'string') {
-        throw r;
-    }
+    assertEq(r, 'string');
 };
 export const unionMulti = () => {
     const r = union(['string', 'number']);
-    if (r !== 'string|number') {
-        throw r;
-    }
+    assertEq(r, 'string|number');
 };
 export const printerReadonlyTuple = () => {
     const r = ro.tuple(['string', 'number']);
-    if (r !== 'readonly[string,number]') {
-        throw r;
-    }
+    assertEq(r, 'readonly[string,number]');
 };
 export const printerReadonlyStruct = () => {
     const r = ro.struct([['x', 'number'], ['y', 'string']]);
@@ -75,9 +54,7 @@ export const printerReadonlyStruct = () => {
 };
 export const printerReadonlyArray = () => {
     const r = ro.array('string');
-    if (r !== 'readonly(string)[]') {
-        throw r;
-    }
+    assertEq(r, 'readonly(string)[]');
 };
 export const printerReadonlyRecord = () => {
     const r = ro.record('number');
@@ -87,9 +64,7 @@ export const printerReadonlyRecord = () => {
 };
 export const printerMutableTuple = () => {
     const r = mut.tuple(['string', 'number']);
-    if (r !== '[string,number]') {
-        throw r;
-    }
+    assertEq(r, '[string,number]');
 };
 export const printerMutableStruct = () => {
     const r = mut.struct([['x', 'number']]);
@@ -99,9 +74,7 @@ export const printerMutableStruct = () => {
 };
 export const printerMutableArray = () => {
     const r = mut.array('string');
-    if (r !== '(string)[]') {
-        throw r;
-    }
+    assertEq(r, '(string)[]');
 };
 export const printerMutableRecord = () => {
     const r = mut.record('number');

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

@@ -2,30 +2,30 @@
  * Conversions between `Uint8Array` values and bit vectors.
  *
  * @deprecated FunctionalScript represents byte data as `bigint`-based bit
- * vectors (`Vec` from `fs/types/bit_vec`). Use `utf8`/`utf8ToString` from
- * `fs/text` for string encoding, and the `bit_vec` module directly for raw
+ * vectors (`Vec` from `fjs/types/bit_vec`). Use `utf8`/`utf8ToString` from
+ * `fjs/text` for string encoding, and the `bit_vec` module directly for raw
  * byte manipulation. `Uint8Array` interop belongs at Node.js boundaries only
  * (e.g. `fromVec`/`toVec` when reading or writing files).
  *
  * @module
  */
+import { assert, assertNotNullish } from '../../asserts/module.f.js';
 import { utf8, utf8ToString } from '../../text/module.f.js';
-import { maxLengthBytes, msb, u8List, u8ListToVec } from '../bit_vec/module.f.js';
+import { maxLengthBytes, msb, tryU8ListToVec, u8List, u8ListToVec } from '../bit_vec/module.f.js';
 import { compose } from '../function/module.f.js';
 import { flat, fromArrayLike, iterable, map } from '../list/module.f.js';
 const u8ListToVecMsb = u8ListToVec(msb);
+const tryU8ListToVecMsb = tryU8ListToVec(msb);
 const u8ListMsb = u8List(msb);
 /**
  * Converts a Uint8Array into an MSB-first bit vector.
  */
 export const toVec = (input) => {
-    if (input.length > maxLengthBytes) {
-        throw "the array is too big";
-    }
+    assert(input.length <= maxLengthBytes, "the array is too big");
     return u8ListToVecMsb(fromArrayLike(input));
 };
 const m = map(fromArrayLike);
-export const listToVec = (input) => u8ListToVecMsb(flat(m(input)));
+export const listToVec = (input) => assertNotNullish(tryU8ListToVecMsb(flat(m(input))), "the array is too big");
 /**
  * Converts an MSB-first bit vector into a Uint8Array.
  */

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

@@ -10,5 +10,8 @@ export declare const proof: {
     utf8RoundTrip: () => void;
     listToVec: () => void;
     maxLength: () => import("../bit_vec/module.f.ts").Vec;
-    throw: () => import("../bit_vec/module.f.ts").Vec;
+    throw: {
+        toVec: () => import("../bit_vec/module.f.ts").Vec;
+        listToVec: () => import("../bit_vec/module.f.ts").Vec;
+    };
 };

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

@@ -2,15 +2,12 @@ import { maxLength, maxLengthBytes, vec } from '../bit_vec/module.f.js';
 import { toVec, fromVec, listToVec, decodeUtf8, encodeUtf8 } from './module.f.js';
 import { strictEqual } from '../function/operator/module.f.js';
 import { equal, fromArrayLike } from '../list/module.f.js';
+import { assert } from '../../asserts/module.f.js';
 const assertEq = (a, b) => {
-    if (a !== b) {
-        throw [a, b];
-    }
+    assert(a === b, [a, b]);
 };
 const assertArrayEq = (a, b) => {
-    if (!equal(strictEqual)(fromArrayLike(a))(fromArrayLike(b))) {
-        throw [a, b];
-    }
+    assert(equal(strictEqual)(fromArrayLike(a))(fromArrayLike(b)), [a, b]);
 };
 export const proof = {
     empty: () => {
@@ -60,5 +57,8 @@ export const proof = {
         assertArrayEq(fromVec(result), Uint8Array.from([1, 2, 3]));
     },
     maxLength: () => toVec(new Uint8Array(Number(maxLengthBytes))),
-    throw: () => toVec(new Uint8Array(Number(maxLengthBytes) + 1)),
+    throw: {
+        toVec: () => toVec(new Uint8Array(Number(maxLengthBytes) + 1)),
+        listToVec: () => listToVec([new Uint8Array(Number(maxLengthBytes)), Uint8Array.from([0])]),
+    },
 };