functionalscript 0.36.0 → 0.38.0

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

@@ -9,7 +9,7 @@ export type ConstObject = Struct | Tuple;
 export type Struct = StringMap<string, Type>;
 /** A tuple schema: readonly array whose elements are nested `Type`s. */
 export type Tuple = readonly Type[];
-declare const primitive0List: readonly ["bigint", "boolean", "number", "string"];
+declare const primitive0List: readonly ['bigint', 'boolean', 'number', 'string'];
 export type Primitive0 = typeof primitive0List[number];
 export declare const tag0List: readonly ["bigint", "boolean", "number", "string", "unknown"];
 /** Tags for nullary (zero-parameter) type schemas. */
@@ -40,7 +40,7 @@ export declare const bigint: Bigint;
 export type Unknown = Type0<'unknown'>;
 /** Schema that validates any DJS-compatible value. */
 export declare const unknown: Unknown;
-declare const tag1List: readonly ["array", "record"];
+declare const tag1List: readonly ['array', 'record'];
 export declare const isTag1: Includes<string, typeof tag1List>;
 /** Tags for unary (one-parameter) type schemas. */
 export type Tag1 = typeof tag1List[number];

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

@@ -1,4 +1,4 @@
-import { includes } from "../array/module.f.js";
+import { includes } from '../array/module.f.js';
 const primitive0List = ['bigint', 'boolean', 'number', 'string'];
 export const tag0List = [...primitive0List, 'unknown'];
 const type0 = (tag) => () => [tag];

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

@@ -26,20 +26,20 @@
  *
  * @module
  */
-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";
-export {} from "../common/module.f.js";
+import {} from '../module.f.js';
+import { ok } from '../../result/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 { parse } from './module.f.js';
+import { boolean, number, string, bigint, unknown, array, record, or, option } from '../module.f.js';
+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/ts/module.f.js

@@ -7,7 +7,7 @@
  * The runtime `toTs` function mirrors `Ts<T>` at value level, returning a TypeScript
  * type expression string for a given RTTI schema.
  */
-import { primitive, union, printer as tsPrinter } from "../../ts/module.f.js";
+import { primitive, union, printer as tsPrinter } from '../../ts/module.f.js';
 /**
  * Creates a printer that converts an RTTI schema `Type` to its TypeScript type expression as a string.
  *

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

@@ -1,5 +1,5 @@
-import { printer } from "./module.f.js";
-import { boolean, number, string, bigint, unknown, array, record, or, option, never } from "../module.f.js";
+import { printer } from './module.f.js';
+import { boolean, number, string, bigint, unknown, array, record, or, option, never } from '../module.f.js';
 const toTs = printer();
 const toTsMut = printer(true);
 const eqMut = (rtti, expected) => {

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";
-export { constPrimitiveValidate, prependPath, primitive0Validate, verror, } from "../common/module.f.js";
+import {} from '../module.f.js';
+import { ok } from '../../result/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 { validate } from './module.f.js';
+import { boolean, number, string, bigint, unknown, array, record, or, option } from '../module.f.js';
+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/module.f.js

@@ -3,9 +3,9 @@
  *
  * @module
  */
-import { bsearch } from "../function/compare/module.f.js";
-import { next } from "../list/module.f.js";
-import { identity } from "../function/module.f.js";
+import { bsearch } from '../function/compare/module.f.js';
+import { next } from '../list/module.f.js';
+import { identity } from '../function/module.f.js';
 /**
  * Two-way sorted-list merge.
  * `reduceOp` returns `[output, sign, nextState]` where sign `-1` advances `a`, `1` advances `b`, `0` advances both; `null` output skips emission.

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

@@ -1,59 +1,46 @@
-import { find, merge } from "./module.f.js";
-import { stringify } from "../../json/module.f.js";
-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 { find, merge } from './module.f.js';
+import { stringify } from '../../media/json/module.f.js';
+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/module.f.js

@@ -1,5 +1,5 @@
 import { toArray } from "../list/module.f.js";
-import { merge, intersect as listIntersect, find } from "../sorted_list/module.f.js";
+import { merge, intersect as listIntersect, find } from '../sorted_list/module.f.js';
 export const union = cmp => a => b => toArray(merge(cmp)(a)(b));
 export const intersect = cmp => a => b => toArray(listIntersect(cmp)(a)(b));
 export const has = cmp => value => set => find(cmp)(value)(set) === value;

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

@@ -1,9 +1,10 @@
-import { has, intersect, union } from "./module.f.js";
-import { stringify } from "../../json/module.f.js";
-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 { has, intersect, union } from './module.f.js';
+import { stringify } from '../../media/json/module.f.js';
+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

@@ -15,10 +15,10 @@
  * cmp('apple')('banana') // -1
  * ```
  */
-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 { 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';
 const reduce = o => listReduce(o)('');
 export const join = compose(joinOp)(reduce);
 export const concat = reduce(concatOp);

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, '');
+        },
+    }
+};