functionalscript 0.36.0 → 0.38.0

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

@@ -5,10 +5,10 @@
  *
  * @module
  */
-import { isArray } from "../array/module.f.js";
-import { iterable } from "../list/module.f.js";
-import { fromUndefined } from "../nullable/module.f.js";
-import { entries as mapEntries, fromEntries as mapFromEntries } from "../ordered_map/module.f.js";
+import { isArray } from '../array/module.f.js';
+import { iterable } from '../list/module.f.js';
+import { fromUndefined } from '../nullable/module.f.js';
+import { entries as mapEntries, fromEntries as mapFromEntries } from '../ordered_map/module.f.js';
 const { getOwnPropertyDescriptor, fromEntries: objectFromEntries } = Object;
 export const at = name => object => {
     const d = getOwnPropertyDescriptor(object, name);

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

@@ -1,4 +1,5 @@
-import { at } from "./module.f.js";
+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/ordered_map/module.f.js

@@ -1,9 +1,9 @@
-import { value, find } from "../btree/find/module.f.js";
-import { set } from "../btree/set/module.f.js";
-import { remove as btreeRemove } from "../btree/remove/module.f.js";
-import { values } from "../btree/module.f.js";
-import { cmp } from "../string/module.f.js";
-import { fold } from "../list/module.f.js";
+import { value, find } from '../btree/find/module.f.js';
+import { set } from '../btree/set/module.f.js';
+import { remove as btreeRemove } from '../btree/remove/module.f.js';
+import { values } from '../btree/module.f.js';
+import { cmp } from '../string/module.f.js';
+import { fold } from '../list/module.f.js';
 const keyCmp = a => ([b]) => cmp(a)(b);
 export const at = (name) => (map) => {
     if (map === null) {

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

@@ -1,6 +1,6 @@
-import { at, setReplace, setReduce, empty, entries, remove, fromEntries } from "./module.f.js";
-import { toArray } from "../list/module.f.js";
-import { assertEq } from "../../asserts/module.f.js";
+import { at, setReplace, setReduce, empty, entries, remove, fromEntries } from './module.f.js';
+import { toArray } from '../list/module.f.js';
+import { assertEq } from '../../asserts/module.f.js';
 export const proof = {
     main: [
         () => {

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

@@ -0,0 +1,13 @@
+declare const empty: () => void;
+declare const singleLeaf: () => void;
+declare const twoLeaves: () => void;
+declare const descending: () => void;
+declare const ascending: () => void;
+export declare const proof: {
+    empty: typeof empty;
+    singleLeaf: typeof singleLeaf;
+    twoLeaves: typeof twoLeaves;
+    descending: typeof descending;
+    ascending: typeof ascending;
+};
+export {};

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

@@ -1,5 +1,5 @@
-import { assert } from "../../asserts/module.f.js";
-import { emptyState, patriciaTrie } from "./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) => {
     const h = combine(a, b);
@@ -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 "../monoid/module.f.js";
-import { assert } from "../../asserts/module.f.js";
+import { repeat } from '../../common/monoid/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/prime_field/proof.f.js

@@ -1,5 +1,5 @@
-import { modSqrt, prime_field, sqrt } from "./module.f.js";
-import { assert, assertEq } from "../../asserts/module.f.js";
+import { modSqrt, prime_field, sqrt } from './module.f.js';
+import { assert, assertEq } from '../../asserts/module.f.js';
 export const proof = {
     throw: {
         reciprocal_zero: () => prime_field(7n).reciprocal(0n),

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/module.f.js

@@ -34,10 +34,10 @@
  * if (rmOps.get(16)(merged) !== 0) { throw 'error' }
  * ```
  */
-import { genericMerge } from "../sorted_list/module.f.js";
-import { next } from "../list/module.f.js";
-import { cmp } from "../number/module.f.js";
-import { bsearch } from "../function/compare/module.f.js";
+import { genericMerge } from '../sorted_list/module.f.js';
+import { next } from '../list/module.f.js';
+import { cmp } from '../number/module.f.js';
+import { bsearch } from '../function/compare/module.f.js';
 const reduceOp = ({ union, equal }) => state => ([aItem, aMax]) => ([bItem, bMax]) => {
     const sign = cmp(aMax)(bMax);
     const min = sign === 1 ? bMax : aMax;

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

@@ -1,10 +1,11 @@
-import { get, merge, fromRange, rangeMap } from "./module.f.js";
-import { stringify } from "../../json/module.f.js";
-import { sort } from "../object/module.f.js";
-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 { get, merge, fromRange, rangeMap } from './module.f.js';
+import { stringify } from '../../media/json/module.f.js';
+import { sort } from '../object/module.f.js';
+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/module.js

@@ -1,4 +1,4 @@
-import { ok, error } from "./module.f.js";
+import { ok, error } from './module.f.js';
 export const tryCatch = f => {
     // Side effect: `try catch` is not allowed in FunctionalScript.
     try {

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

@@ -0,0 +1,12 @@
+declare const example: () => void;
+declare const invertTest: () => void;
+declare const mapOkTest: () => void;
+export declare const proof: {
+    example: typeof example;
+    invertTest: typeof invertTest;
+    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

@@ -1,7 +1,7 @@
-import {} from "../module.f.js";
-import { error, ok } from "../../result/module.f.js";
-import { isArray as commonIsArray } from "../../array/module.f.js";
-import { isObject as commonIsObject } from "../../object/module.f.js";
+import {} from '../module.f.js';
+import { error, ok } from '../../result/module.f.js';
+import { isArray as commonIsArray } from '../../array/module.f.js';
+import { isObject as commonIsObject } from '../../object/module.f.js';
 /** Builds an error result with empty path and the given message. */
 export const verror = (message) => error({ path: [], message });
 /** Prepends `key` to the error's path, used to build the path bottom-up. */
@@ -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`.
  *