functionalscript 0.37.0 → 0.38.0

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

@@ -1,4 +1,5 @@
 import { at } from './module.f.js';
+import { assertEq } from '../../asserts/module.f.js';
 export const proof = {
     stringMap: {
         infiniteIsOptional: true,
@@ -7,15 +8,11 @@ export const proof = {
     ctor: () => {
         const a = {};
         const value = at('constructor')(a);
-        if (value !== null) {
-            throw value;
-        }
+        assertEq(value, null);
     },
     property: () => {
         const a = { constructor: 42 };
         const value = at('constructor')(a);
-        if (value !== 42) {
-            throw value;
-        }
+        assertEq(value, 42);
     }
 };

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

@@ -1,4 +1,4 @@
-import { assert } from '../../asserts/module.f.js';
+import { assert, assertEq } from '../../asserts/module.f.js';
 import { emptyState, patriciaTrie } from './module.f.js';
 const combine = (a, b) => a * 1000n + b;
 const create = (a, b, s) => {
@@ -14,53 +14,53 @@ const runExample = (inputs, expectedLeaves, expectedNodeCounts) => {
         const prevCount = state[0].length;
         state = push([x, x], state);
         const actual = leaves(state);
-        assert(actual.length === expectedLeaves[i].length);
+        assertEq(actual.length, expectedLeaves[i].length);
         for (let j = 0; j < actual.length; j++) {
-            assert(actual[j] === expectedLeaves[i][j]);
+            assertEq(actual[j], expectedLeaves[i][j]);
         }
         const newNodes = state[0].slice(prevCount);
-        assert(newNodes.length === expectedNodeCounts[i]);
+        assertEq(newNodes.length, expectedNodeCounts[i]);
         for (const [l, r, h] of newNodes) {
-            assert(h === combine(l, r));
+            assertEq(h, combine(l, r));
         }
     }
     const prevCount = state[0].length;
     const [root, finalStorage] = end(state);
     const finalNodes = finalStorage.slice(prevCount);
-    assert(finalNodes.length === expectedLeaves[expectedLeaves.length - 1].length - 1);
+    assertEq(finalNodes.length, expectedLeaves[expectedLeaves.length - 1].length - 1);
     assert(root !== undefined);
     for (const [l, r, h] of finalNodes) {
-        assert(h === combine(l, r));
+        assertEq(h, combine(l, r));
     }
 };
 const empty = () => {
     const [root, storage] = end(emptyState([]));
-    assert(storage.length === 0);
-    assert(root === undefined);
+    assertEq(storage.length, 0);
+    assertEq(root, undefined);
 };
 const singleLeaf = () => {
     const state = push([42n, 42n], emptyState([]));
-    assert(state[0].length === 0);
-    assert(leaves(state).length === 1);
-    assert(leaves(state)[0] === 42n);
+    assertEq(state[0].length, 0);
+    assertEq(leaves(state).length, 1);
+    assertEq(leaves(state)[0], 42n);
     const [root, finalStorage] = end(state);
-    assert(finalStorage.length === 0);
-    assert(root === 42n);
+    assertEq(finalStorage.length, 0);
+    assertEq(root, 42n);
 };
 const twoLeaves = () => {
     const s1 = push([7n, 7n], emptyState([]));
     const prevCount = s1[0].length;
     const s2 = push([3n, 3n], s1);
-    assert(s2[0].slice(prevCount).length === 0);
-    assert(leaves(s2).length === 2);
+    assertEq(s2[0].slice(prevCount).length, 0);
+    assertEq(leaves(s2).length, 2);
     const prevCount2 = s2[0].length;
     const [root, finalStorage] = end(s2);
     const finalNodes = finalStorage.slice(prevCount2);
-    assert(finalNodes.length === 1);
-    assert(finalNodes[0][0] === 7n);
-    assert(finalNodes[0][1] === 3n);
-    assert(finalNodes[0][2] === combine(7n, 3n));
-    assert(root === combine(7n, 3n));
+    assertEq(finalNodes.length, 1);
+    assertEq(finalNodes[0][0], 7n);
+    assertEq(finalNodes[0][1], 3n);
+    assertEq(finalNodes[0][2], combine(7n, 3n));
+    assertEq(root, combine(7n, 3n));
 };
 // example.md — descending
 // merges happen at: step 2 (1), 3 (1), 4 (1), 7 (2), 8 (2), A (1), C (2), F (1)

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

@@ -1,5 +1,5 @@
 import { repeat } from '../../common/monoid/module.f.js';
-import { assert } from '../../asserts/module.f.js';
+import { assertNotNullish } from '../../asserts/module.f.js';
 /**
  * Creates a prime field with the specified prime modulus and associated operations.
  *
@@ -102,16 +102,11 @@ export const modSqrt = (field) => {
     return x => {
         const v = reduce(x);
         const r = sqrt_p(v);
-        if (r !== null) {
-            return r;
-        }
         // For a prime `p ≡ 3 (mod 4)`, `−1` is a non-residue, so exactly one of
         // `±v` is a quadratic residue: if `v` has no root, `neg(v)` must — hence
         // `s` is non-null. `sqrt` already enforces `p ≡ 3 (mod 4)`, but primality
         // is never checked, so the only way to reach `s === null` is a *composite*
         // modulus (where the residue argument breaks).
-        const s = sqrt_p(neg(v));
-        assert(s !== null, 'modSqrt');
-        return s;
+        return r !== null ? r : assertNotNullish(sqrt_p(neg(v)), 'modSqrt');
     };
 };

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

@@ -4,5 +4,5 @@
  * @module
  */
 export type Range = readonly [number, number];
-export declare const contains: (range: Range) => (i: number) => boolean;
+export declare const contains: (...range: Range) => (i: number) => boolean;
 export declare const one: (i: number) => Range;

package/fjs/types/range/module.f.js

@@ -0,0 +1,2 @@
+export const contains = (b, e) => i => b <= i && i <= e;
+export const one = a => [a, a];

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

@@ -0,0 +1,9 @@
+import { contains } from './module.f.js';
+import { assert } from '../../asserts/module.f.js';
+export const proof = () => {
+    assert(contains(0, 5)(1), 1);
+    assert(contains(0, 5)(0), 0);
+    assert(contains(0, 5)(5), 5);
+    assert(!(contains(0, 5)(-1)), -1);
+    assert(!(contains(0, 5)(6)), 6);
+};

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

@@ -5,6 +5,7 @@ import { union } from '../sorted_set/module.f.js';
 import { equal, toArray } from '../list/module.f.js';
 import { strictEqual } from '../function/operator/module.f.js';
 import { cmp } from '../string/module.f.js';
+import { assertEq } from '../../asserts/module.f.js';
 const str = stringify(sort);
 const op = {
     union: union(cmp),
@@ -25,31 +26,17 @@ export const proof = {
         const merged = toArray(rmOps.merge(range1)(range2));
         // Retrieve values from the merged range map
         //
-        if (rmOps.get(-1)(merged) !== 0) {
-            throw 'error';
-        }
+        assertEq(rmOps.get(-1)(merged), 0, 'error');
         //
-        if (rmOps.get(0)(merged) !== 2) {
-            throw 'error';
-        }
-        if (rmOps.get(2)(merged) !== 2) {
-            throw 'error';
-        }
+        assertEq(rmOps.get(0)(merged), 2, 'error');
+        assertEq(rmOps.get(2)(merged), 2, 'error');
         // 2 | 5 = 7
-        if (rmOps.get(7)(merged) !== 7) {
-            throw 'error';
-        }
+        assertEq(rmOps.get(7)(merged), 7, 'error');
         //
-        if (rmOps.get(12)(merged) !== 5) {
-            throw 'error';
-        }
-        if (rmOps.get(15)(merged) !== 5) {
-            throw 'error';
-        }
+        assertEq(rmOps.get(12)(merged), 5, 'error');
+        assertEq(rmOps.get(15)(merged), 5, 'error');
         //
-        if (rmOps.get(16)(merged) !== 0) {
-            throw 'error';
-        }
+        assertEq(rmOps.get(16)(merged), 0, 'error');
     },
     merge: [
         () => {
@@ -57,63 +44,49 @@ export const proof = {
             const b = null;
             const merged = merge(op)(a)(b);
             const result = str(toArray(merged));
-            if (result !== '[[["a"],1],[["b"],2]]') {
-                throw result;
-            }
+            assertEq(result, '[[["a"],1],[["b"],2]]');
         },
         () => {
             const a = null;
             const b = [[['a'], 1], [['b'], 2]];
             const merged = merge(op)(a)(b);
             const result = str(toArray(merged));
-            if (result !== '[[["a"],1],[["b"],2]]') {
-                throw result;
-            }
+            assertEq(result, '[[["a"],1],[["b"],2]]');
         },
         () => {
             const a = [[['a'], 1], [['b'], 2]];
             const b = [[['a'], 1], [['b'], 2]];
             const merged = merge(op)(a)(b);
             const result = str(toArray(merged));
-            if (result !== '[[["a"],1],[["b"],2]]') {
-                throw result;
-            }
+            assertEq(result, '[[["a"],1],[["b"],2]]');
         },
         () => {
             const a = [[['a'], 1], [['c'], 3]];
             const b = [[['b'], 2], [['d'], 4]];
             const merged = merge(op)(a)(b);
             const result = str(toArray(merged));
-            if (result !== '[[["a","b"],1],[["b","c"],2],[["c","d"],3],[["d"],4]]') {
-                throw result;
-            }
+            assertEq(result, '[[["a","b"],1],[["b","c"],2],[["c","d"],3],[["d"],4]]');
         },
         () => {
             const a = [[['a'], 1], [['d'], 4]];
             const b = [[['b'], 2], [['c'], 3]];
             const merged = merge(op)(a)(b);
             const result = str(toArray(merged));
-            if (result !== '[[["a","b"],1],[["b","d"],2],[["c","d"],3],[["d"],4]]') {
-                throw result;
-            }
+            assertEq(result, '[[["a","b"],1],[["b","d"],2],[["c","d"],3],[["d"],4]]');
         },
         () => {
             const a = [[['a'], 1], [['b'], 2]];
             const b = [[['b'], 1], [['a'], 2]];
             const merged = merge(op)(a)(b);
             const result = str(toArray(merged));
-            if (result !== '[[["a","b"],2]]') {
-                throw result;
-            }
+            assertEq(result, '[[["a","b"],2]]');
         },
         () => {
             const a = [[['a'], 1], [['b'], 2], [['a'], 3]];
             const b = [[['a'], 5]];
             const merged = merge(op)(a)(b);
             const result = str(toArray(merged));
-            if (result !== '[[["a"],1],[["a","b"],2],[["a"],5]]') {
-                throw result;
-            }
+            assertEq(result, '[[["a"],1],[["a","b"],2],[["a"],5]]');
         }
     ],
     get: () => {
@@ -123,58 +96,42 @@ export const proof = {
             () => {
                 const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
                 const result = str(at(5)(rm));
-                if (result !== '["a"]') {
-                    throw result;
-                }
+                assertEq(result, '["a"]');
             },
             () => {
                 const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
                 const result = str(at(10)(rm));
-                if (result !== '["a"]') {
-                    throw result;
-                }
+                assertEq(result, '["a"]');
             },
             () => {
                 const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
                 const result = str(at(15)(rm));
-                if (result !== '["b"]') {
-                    throw result;
-                }
+                assertEq(result, '["b"]');
             },
             () => {
                 const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
                 const result = str(at(20)(rm));
-                if (result !== '["b"]') {
-                    throw result;
-                }
+                assertEq(result, '["b"]');
             },
             () => {
                 const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
                 const result = str(at(25)(rm));
-                if (result !== '["c"]') {
-                    throw result;
-                }
+                assertEq(result, '["c"]');
             },
             () => {
                 const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
                 const result = str(at(30)(rm));
-                if (result !== '["c"]') {
-                    throw result;
-                }
+                assertEq(result, '["c"]');
             },
             () => {
                 const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
                 const result = str(at(35)(rm));
-                if (result !== '[]') {
-                    throw result;
-                }
+                assertEq(result, '[]');
             },
             () => {
                 const rm = [];
                 const result = str(at(10)(rm));
-                if (result !== '[]') {
-                    throw result;
-                }
+                assertEq(result, '[]');
             }
         ];
     },
@@ -184,33 +141,23 @@ export const proof = {
         return [
             () => {
                 const result = get(def)(0)(rm);
-                if (result !== -1) {
-                    throw result;
-                }
+                assertEq(result, -1);
             },
             () => {
                 const result = get(def)(1)(rm);
-                if (result !== 42) {
-                    throw result;
-                }
+                assertEq(result, 42);
             },
             () => {
                 const result = get(def)(3)(rm);
-                if (result !== 42) {
-                    throw result;
-                }
+                assertEq(result, 42);
             },
             () => {
                 const result = get(def)(7)(rm);
-                if (result !== 42) {
-                    throw result;
-                }
+                assertEq(result, 42);
             },
             () => {
                 const result = get(def)(9)(rm);
-                if (result !== -1) {
-                    throw result;
-                }
+                assertEq(result, -1);
             },
         ];
     }

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

@@ -1,11 +1,12 @@
 declare const example: () => void;
 declare const invertTest: () => void;
-declare const unwrapError: () => void;
 declare const mapOkTest: () => void;
 export declare const proof: {
     example: typeof example;
     invertTest: typeof invertTest;
-    unwrapError: typeof unwrapError;
     mapOkTest: typeof mapOkTest;
+    throw: {
+        unwrapError: () => string;
+    };
 };
 export {};

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

@@ -0,0 +1,31 @@
+import { error, ok, unwrap, invert, mapOk } from "./module.f.js";
+import { assert, assertEq } from '../../asserts/module.f.js';
+const example = () => {
+    const success = ok(42);
+    const failure = error('Something went wrong');
+    assertEq(unwrap(success), 42, 'error');
+    const [kind, v] = failure;
+    assertEq(kind, 'error');
+    // `v` is inferred as `string` here
+    assertEq(v, 'Something went wrong', 'error');
+};
+const invertTest = () => {
+    const [k0, v0] = invert(ok(42));
+    assert(!(k0 !== 'error' || v0 !== 42), [k0, v0]);
+    const [k1, v1] = invert(error('oops'));
+    assert(!(k1 !== 'ok' || v1 !== 'oops'), [k1, v1]);
+};
+const mapOkTest = () => {
+    const [k0, v0] = mapOk((n) => n + 1)(ok(41));
+    assert(!(k0 !== 'ok' || v0 !== 42), [k0, v0]);
+    const [k1, v1] = mapOk((n) => n + 1)(error('oops'));
+    assert(!(k1 !== 'error' || v1 !== 'oops'), [k1, v1]);
+};
+export const proof = {
+    example,
+    invertTest,
+    mapOkTest,
+    throw: {
+        unwrapError: () => unwrap(error('oops')),
+    },
+};

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

@@ -15,6 +15,11 @@
  *   with one handler per variant; `visit(v)(rtti)` recognizes `rtti` and
  *   calls the matching handler. Both consumers compose their top-level
  *   function from a visitor.
+ * - `eachEntry`: the container entry loop (array/record/tuple/struct), shared
+ *   by both consumers' container builders. Callers choose what (if anything)
+ *   to accumulate, so `validate`'s pure pass/fail check pays no allocation.
+ * - `orVisit`: the shared `or` handler — try each variant's recursive walker,
+ *   return the first match.
  *
  * Keeping the kernel here also removes `parse`'s incidental dependency on
  * `validate` and gives future schema-driven consumers (e.g. the data form
@@ -22,7 +27,7 @@
  *
  * @module
  */
-import type { Primitive, Unknown } from '../../../djs/module.f.ts';
+import type { Primitive, Unknown } from '../ts/module.f.ts';
 import { type Info0, type Primitive0, type Struct, type Tag1, type Tuple, type Type } from '../module.f.ts';
 import { type Error, type Result as CommonResult } from '../../result/module.f.ts';
 import type { Ts } from '../ts/module.f.ts';
@@ -74,6 +79,36 @@ export type Container<K extends Tag1> = K extends 'array' ? ReadonlyArray<Unknow
 export declare const isArray: IsContainer<ReadonlyArray<Unknown>>;
 /** `IsContainer` guard for records/structs, shared by `validate` and `parse`. */
 export declare const isObject: IsContainer<StringMap<string, Unknown>>;
+/**
+ * Runs `item` over each `[key, value]` entry, bailing out with the first
+ * error, path-prefixed with that entry's key. On success, folds each item's
+ * result into `acc` (starting from `init`) with `accumulate` and returns the
+ * final accumulator.
+ *
+ * Shared by `validate` and `parse`'s container builders (array/record/tuple/
+ * struct), which differ only in what `item` does with the value and what
+ * they accumulate: `validate` has nothing to collect — its entire schema is
+ * "did every entry succeed?" — so it passes `undefined`/`(acc) => acc` and
+ * pays no allocation per entry; `parse` needs the rebuilt `[key, value]`
+ * pairs, so it folds them into a `List` (see its call site) and converts to
+ * an array once at the end.
+ */
+export declare const eachEntry: <V, R, A>(entries: ReadonlyArray<readonly [string, V]>, item: (k: string, v: V) => CommonResult<R, ValidationError>, init: A, accumulate: (acc: A, k: string, value: R) => A) => CommonResult<A, ValidationError>;
+/** `Result` with the payload type erased; avoids instantiating `Ts<Type>`. */
+export type ResultE = CommonResult<Unknown, ValidationError>;
+/** A `Validate`-shaped function with the payload type erased. */
+export type ValidateE = (value: Unknown) => ResultE;
+/**
+ * First variant in `variants` that `recurse` accepts, else `verror('no match')`.
+ *
+ * Shared `or` handler for `validate` and `parse`: both try each variant
+ * against the value and return the first `'ok'` verbatim, differing only in
+ * which recursive function (`validate` or `parse`) walks each variant. `recurse`
+ * is typed over the erased `ValidateE` alias — annotating it as `(t: Type) =>
+ * Validate<Type>` would itself instantiate `Validate<Type>` and hit TS2589 —
+ * so each caller passes its recursive function through one boundary cast.
+ */
+export declare const orVisit: (recurse: (t: Type) => ValidateE) => (variants: readonly Type[]) => (value: Unknown) => ResultE;
 /**
  * Visits a schema `Type` by dispatching to the matching handler in `v`.
  *

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

@@ -25,6 +25,50 @@ const visitConst = (v) => (c) => typeof c === 'object' && c !== null
 export const isArray = value => commonIsArray(value);
 /** `IsContainer` guard for records/structs, shared by `validate` and `parse`. */
 export const isObject = value => commonIsObject(value);
+/**
+ * Runs `item` over each `[key, value]` entry, bailing out with the first
+ * error, path-prefixed with that entry's key. On success, folds each item's
+ * result into `acc` (starting from `init`) with `accumulate` and returns the
+ * final accumulator.
+ *
+ * Shared by `validate` and `parse`'s container builders (array/record/tuple/
+ * struct), which differ only in what `item` does with the value and what
+ * they accumulate: `validate` has nothing to collect — its entire schema is
+ * "did every entry succeed?" — so it passes `undefined`/`(acc) => acc` and
+ * pays no allocation per entry; `parse` needs the rebuilt `[key, value]`
+ * pairs, so it folds them into a `List` (see its call site) and converts to
+ * an array once at the end.
+ */
+export const eachEntry = (entries, item, init, accumulate) => {
+    let acc = init;
+    for (const [k, v] of entries) {
+        const r = item(k, v);
+        if (r[0] === 'error') {
+            return prependPath(k, r);
+        }
+        acc = accumulate(acc, k, r[1]);
+    }
+    return ok(acc);
+};
+/**
+ * First variant in `variants` that `recurse` accepts, else `verror('no match')`.
+ *
+ * Shared `or` handler for `validate` and `parse`: both try each variant
+ * against the value and return the first `'ok'` verbatim, differing only in
+ * which recursive function (`validate` or `parse`) walks each variant. `recurse`
+ * is typed over the erased `ValidateE` alias — annotating it as `(t: Type) =>
+ * Validate<Type>` would itself instantiate `Validate<Type>` and hit TS2589 —
+ * so each caller passes its recursive function through one boundary cast.
+ */
+export const orVisit = (recurse) => (variants) => (value) => {
+    for (const t of variants) {
+        const r = recurse(t)(value);
+        if (r[0] === 'ok') {
+            return r;
+        }
+    }
+    return verror('no match');
+};
 /**
  * Visits a schema `Type` by dispatching to the matching handler in `v`.
  *

package/fjs/types/rtti/common/proof.f.d.ts

@@ -0,0 +1,8 @@
+export declare const proof: {
+    empty: () => void;
+    allOk: () => void;
+    noAccumulate: () => void;
+    firstErrorWins: () => void;
+    shortCircuits: () => void;
+    pathPrefixed: () => void;
+};

package/fjs/types/rtti/common/proof.f.js

@@ -0,0 +1,51 @@
+import { eachEntry } from './module.f.js';
+import { error, ok } from '../../result/module.f.js';
+import { assert, assertEq } from '../../../asserts/module.f.js';
+const item = (k, v) => v < 0 ? error({ path: [], message: `negative at ${k}` }) : ok(v * 2);
+/** Mirrors `parse`'s accumulate step, kept simple (a small test list, not a `List`). */
+const collect = (acc, k, v) => [...acc, [k, v]];
+export const proof = {
+    empty: () => {
+        const r = eachEntry([], item, [], collect);
+        assert(r[0] === 'ok');
+        assertEq(r[1].length, 0);
+    },
+    allOk: () => {
+        const r = eachEntry([['a', 1], ['b', 2]], item, [], collect);
+        assert(r[0] === 'ok');
+        assertEq(r[1].length, 2);
+        assertEq(r[1][0][0], 'a');
+        assertEq(r[1][0][1], 2);
+        assertEq(r[1][1][0], 'b');
+        assertEq(r[1][1][1], 4);
+    },
+    // Mirrors `validate`'s usage: nothing is collected, only pass/fail matters.
+    noAccumulate: () => {
+        const r = eachEntry([['a', 1]], item, undefined, () => undefined);
+        assert(r[0] === 'ok');
+        assertEq(r[1], undefined);
+    },
+    firstErrorWins: () => {
+        const r = eachEntry([['a', -1], ['b', -2]], item, [], collect);
+        assert(r[0] === 'error');
+        assertEq(r[1].message, 'negative at a');
+    },
+    shortCircuits: () => {
+        let calls = 0;
+        const counting = (k, v) => {
+            calls++;
+            return item(k, v);
+        };
+        const r = eachEntry([['a', -1], ['b', -2], ['c', -3]], counting, [], collect);
+        assert(r[0] === 'error');
+        assertEq(calls, 1);
+    },
+    pathPrefixed: () => {
+        const nested = (k, v) => v < 0 ? error({ path: ['inner'], message: 'bad' }) : ok(v);
+        const r = eachEntry([['outer', -1]], nested, [], collect);
+        assert(r[0] === 'error');
+        assertEq(r[1].path.length, 2);
+        assertEq(r[1].path[0], 'outer');
+        assertEq(r[1].path[1], 'inner');
+    },
+};

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.
  *