functionalscript 0.37.0 → 0.39.0

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

@@ -28,18 +28,18 @@
  */
 import {} from '../module.f.js';
 import { ok } from '../../result/module.f.js';
-import { find, map as listMap } from '../../list/module.f.js';
-import { constPrimitiveValidate, isArray, isObject, prependPath, primitive0Validate, verror, visit, } from '../common/module.f.js';
+import { reverse, toArray } from '../../list/module.f.js';
+import { constPrimitiveValidate, eachEntry, isArray, isObject, orVisit, primitive0Validate, verror, visit, } from '../common/module.f.js';
 export {} from '../common/module.f.js';
 const { entries } = Object;
-const keyedFirstError = (results) => {
-    const e = results.find(([, r]) => r[0] === 'error');
-    return e === undefined ? null : [e[0], e[1]];
-};
 const arrayRebuild = entries => entries.map(([, v]) => v);
 const recordRebuild = entries => Object.fromEntries(entries);
-/** Drops the `'ok'` tag from each result, yielding the rebuild's `[key, value]` entries. */
-const okEntries = (results) => results.map(([k, r]) => [k, r[1]]);
+/** `eachEntry`'s accumulator seed: entries are consed on in reverse as they parse. */
+const emptyEntries = null;
+/** `eachEntry`'s accumulate step: an O(1) prepend, unlike rebuilding an array on every entry. */
+const consEntry = (acc, k, v) => ({ first: [k, v], tail: acc });
+/** Restores forward order from `consEntry`'s reverse-order list, in one linear pass. */
+const orderedEntries = (list) => toArray(reverse(list));
 /**
  * Builds a parser for `array` or `record` schemas. Mirrors `validate`'s
  * `containerValidate`, but rebuilds a fresh container from each item's parsed
@@ -56,11 +56,8 @@ const containerParse = (isContainer, rebuild) => (item) => value => {
         return ok(rebuild([]));
     }
     const itemParse = parse(item);
-    const results = e.map(([k, v]) => [k, itemParse(v)]);
-    const err = keyedFirstError(results);
-    return err === null
-        ? ok(rebuild(okEntries(results)))
-        : prependPath(err[0], err[1]);
+    const r = eachEntry(e, (_k, v) => itemParse(v), emptyEntries, consEntry);
+    return r[0] === 'error' ? r : ok(rebuild(orderedEntries(r[1])));
 };
 const arrayParse = containerParse(isArray, arrayRebuild);
 const recordParse = containerParse(isObject, recordRebuild);
@@ -74,18 +71,12 @@ const constContainerParse = (isContainer, getItem, rebuild) => (rtti) => value =
     if (!isContainer(value)) {
         return verror('unexpected value');
     }
-    const results = entries(rtti).map(([k, t]) => [k, parse(t)(getItem(value, k))]);
-    const err = keyedFirstError(results);
-    return err === null
-        ? ok(rebuild(okEntries(results)))
-        : prependPath(err[0], err[1]);
+    const r = eachEntry(entries(rtti), (k, t) => parse(t)(getItem(value, k)), emptyEntries, consEntry);
+    return r[0] === 'error' ? r : ok(rebuild(orderedEntries(r[1])));
 };
 const tupleParse = constContainerParse(isArray, (value, k) => value[Number(k)], arrayRebuild);
 const structParse = constContainerParse(isObject, (value, k) => value[k], recordRebuild);
-const findFirst = find(verror('no match'))((k) => k[0] === 'ok');
-const orParse = (rtti) => 
-// `parse(t)` where t: Type forces Ts<Type> evaluation → TS2589; cast keeps result as any.
-value => findFirst(listMap(t => parse(t)(value))(rtti));
+const orParse = (rtti) => orVisit(parse)(rtti);
 /**
  * Creates a parser function for the given RTTI schema.
  *

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/{fs → fjs}/types/string/module.f.js

@@ -18,10 +18,18 @@
 import { reduce as listReduce, repeat as listRepeat } from '../list/module.f.js';
 import { compose } from '../function/module.f.js';
 import { cmp as uCmp } from '../function/compare/module.f.js';
-import { join as joinOp, concat as concatOp } from '../function/operator/module.f.js';
+import { join as joinOp } from '../function/operator/module.f.js';
+import { fold } from '../../common/monoid/module.f.js';
+// `join`'s per-separator reduction is seeded at `''` but is *not* a monoid fold:
+// `joinOp(sep)` has no identity (`joinOp(sep)('')(x)` prepends a separator), so
+// it stays a hand-seeded `reduce` rather than going through `monoid.fold`.
 const reduce = o => listReduce(o)('');
 export const join = compose(joinOp)(reduce);
-export const concat = reduce(concatOp);
+// String concatenation with identity `''` is a lawful monoid, so `concat` is a
+// monoid fold. The operation is accumulator-first (`a` on the left), matching
+// `monoid.fold`'s convention — unlike the element-first `concat` in
+// `function/operator`, which is written for `list.reduce`.
+export const concat = fold({ identity: '', operation: a => b => a + b });
 export const repeat = v => compose(listRepeat(v))(concat);
 export const cmp = uCmp;
 export const splitAt = (p) => (v) => [v.substring(0, p), v.substring(p)];

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