functionalscript 0.43.0 → 0.44.0

package/fjs/types/rtti/validate/proof.f.mjs

@@ -0,0 +1,437 @@
+/**
+ * @import { ValidationError } from '../common/types.ts'
+ * @import { Equal } from '../../ts/types.ts'
+ * @import { Ts } from '../ts/types.ts'
+ * @import { Unknown as DjsUnknown } from '../../../djs/types.ts'
+ * @import { Assert } from '../../../asserts/types.ts'
+ */
+
+import { validate } from './module.f.mjs'
+import { boolean, number, string, bigint, unknown, array, record, or, option } from '../module.f.mjs'
+import { assert, assertEq } from '../../../asserts/module.f.mjs'
+
+/** @type {(r: readonly [string, unknown]) => void} */
+const assertOk = ([k]) => { assertEq(k, 'ok', 'expected ok') }
+
+/** @type {(r: readonly [string, unknown]) => void} */
+const assertError = ([k]) => { assertEq(k, 'error', 'expected error') }
+
+/** @type {(expected: readonly string[]) => (r: readonly [string, unknown]) => void} */
+const assertErrorPath = expected =>
+    r => {
+        assert(r[0] === 'error', 'expected error')
+        const e = /** @type {ValidationError} */ (r[1])
+        if (e.path.length !== expected.length) { throw `path length ${e.path.length} != ${expected.length}` }
+        for (let i = 0; i < expected.length; i++) {
+            if (e.path[i] !== expected[i]) { throw `path[${i}] ${e.path[i]} != ${expected[i]}` }
+        }
+    }
+
+export const proof = {
+    boolean: {
+        ok: () => {
+            /** @typedef {Assert<Equal<Ts<typeof boolean>, boolean>>} _RoundTrip */
+            assertOk(validate(boolean)(true))
+            assertOk(validate(boolean)(false))
+        },
+        error: () => {
+            assertError(validate(boolean)(0))
+            assertError(validate(boolean)('true'))
+            assertError(validate(boolean)(null))
+        },
+    },
+    number: {
+        ok: () => {
+            /** @typedef {Assert<Equal<Ts<typeof number>, number>>} _RoundTrip */
+            assertOk(validate(number)(42))
+        },
+        error: () => {
+            assertError(validate(number)('42'))
+            assertError(validate(number)(42n))
+        },
+    },
+    string: {
+        ok: () => {
+            /** @typedef {Assert<Equal<Ts<typeof string>, string>>} _RoundTrip */
+            assertOk(validate(string)('hello'))
+        },
+        error: () => {
+            assertError(validate(string)(42))
+            assertError(validate(string)(null))
+        },
+    },
+    bigint: {
+        ok: () => {
+            /** @typedef {Assert<Equal<Ts<typeof bigint>, bigint>>} _RoundTrip */
+            assertOk(validate(bigint)(4n))
+        },
+        error: () => {
+            assertError(validate(bigint)(4))
+            assertError(validate(bigint)('4'))
+        },
+    },
+    unknown: {
+        ok: () => {
+            /** @typedef {Assert<Equal<Ts<typeof unknown>, DjsUnknown>>} _RoundTrip */
+            assertOk(validate(unknown)(null))
+            assertOk(validate(unknown)(42))
+            assertOk(validate(unknown)('hello'))
+            assertOk(validate(unknown)(true))
+            assertOk(validate(unknown)({}))
+            assertOk(validate(unknown)([]))
+        },
+    },
+    const: {
+        null: {
+            ok: () => {
+                /** @typedef {Assert<Equal<Ts<null>, null>>} _RoundTrip */
+                assertOk(validate(null)(null))
+            },
+            error: () => {
+                assertError(validate(null)(undefined))
+                assertError(validate(null)(0))
+            },
+        },
+        undefined: {
+            ok: () => {
+                /** @typedef {Assert<Equal<Ts<undefined>, undefined>>} _RoundTrip */
+                assertOk(validate(undefined)(undefined))
+            },
+            error: () => assertError(validate(undefined)(null)),
+        },
+        number: {
+            ok: () => {
+                /** @typedef {Assert<Equal<Ts<42>, 42>>} _RoundTrip */
+                assertOk(validate(/** @type {const} */ (42))(42))
+            },
+            error: () => assertError(validate(/** @type {const} */ (42))(43)),
+        },
+        nan: {
+            ok: () => assertOk(validate(/** @type {number} */ (NaN))(NaN)),
+            error: () => {
+                assertError(validate(/** @type {number} */ (NaN))(0))
+                assertError(validate(/** @type {const} */ (0))(NaN))
+                assertError(validate(/** @type {const} */ (42))(NaN))
+            },
+        },
+        infinity: {
+            ok: () => {
+                assertOk(validate(/** @type {number} */ (Infinity))(Infinity))
+                assertOk(validate(/** @type {number} */ (-Infinity))(-Infinity))
+            },
+            error: () => {
+                assertError(validate(/** @type {number} */ (Infinity))(-Infinity))
+                assertError(validate(/** @type {number} */ (Infinity))(0))
+            },
+        },
+        signedZero: {
+            // `Object.is` distinguishes +0 and -0; `===` treats them equal.
+            distinct: () => {
+                assertError(validate(/** @type {const} */ (0))(-0))
+                assertError(validate(/** @type {number} */ (-0))(0))
+            },
+            self: () => {
+                assertOk(validate(/** @type {const} */ (0))(0))
+                assertOk(validate(/** @type {number} */ (-0))(-0))
+            },
+        },
+        string: {
+            ok: () => {
+                /** @typedef {Assert<Equal<Ts<'hello'>, 'hello'>>} _RoundTrip */
+                assertOk(validate(/** @type {const} */ ('hello'))('hello'))
+            },
+            error: () => assertError(validate(/** @type {const} */ ('hello'))('world')),
+        },
+        bigint: {
+            ok: () => {
+                /** @typedef {Assert<Equal<Ts<7n>, 7n>>} _RoundTrip */
+                assertOk(validate(/** @type {const} */ (7n))(7n))
+            },
+            error: () => assertError(validate(/** @type {const} */ (7n))(8n)),
+        },
+        boolean: {
+            ok: () => {
+                /** @typedef {Assert<Equal<Ts<true>, true>>} _RoundTrip */
+                assertOk(validate(/** @type {const} */ (true))(true))
+            },
+            error: () => assertError(validate(/** @type {const} */ (true))(false)),
+        },
+        tuple: {
+            ok: () => {
+                const t = /** @type {const} */ ([42, 'hello'])
+                /** @typedef {Assert<Equal<Ts<typeof t>, readonly[42, 'hello']>>} _RoundTrip */
+                assertOk(validate(t)([42, 'hello']))
+            },
+            extraItems: () => assertOk(validate(/** @type {const} */ ([42]))([42, 'extra'])),
+            error: () => {
+                assertError(validate(/** @type {const} */ ([42]))([99]))
+                assertError(validate(/** @type {const} */ ([42]))({}))
+            },
+        },
+        struct: {
+            ok: () => {
+                const t = /** @type {const} */ ({ a: 42, b: 'hello' })
+                /** @typedef {Assert<Equal<Ts<typeof t>, { readonly a: 42, readonly b: 'hello' }>>} _RoundTrip */
+                assertOk(validate(t)({ a: 42, b: 'hello' }))
+            },
+            extraKeys: () => assertOk(validate(/** @type {const} */ ({ a: /** @type {const} */ (42) }))({ a: 42, b: 'extra' })),
+            error: () => {
+                assertError(validate(/** @type {const} */ ({ a: 42 }))({ a: 99 }))
+                assertError(validate(/** @type {const} */ ({ a: 42 }))([]))
+            },
+        },
+    },
+    array: {
+        empty: () => assertOk(validate(array(number))([])),
+        ok: () => {
+            const t = array(number)
+            /** @typedef {Assert<Equal<Ts<typeof t>, readonly number[]>>} _RoundTrip */
+            assertOk(validate(array(number))([1, 2, 3]))
+        },
+        error: () => {
+            assertError(validate(array(number))([1, 'two', 3]))
+            assertError(validate(array(number))({}))
+            assertError(validate(array(number))(null))
+        },
+        nested: () => {
+            const t = array(array(boolean))
+            /** @typedef {Assert<Equal<Ts<typeof t>, readonly (readonly boolean[])[]>>} _RoundTrip */
+            assertOk(validate(array(array(boolean)))([[true, false], [false]]))
+            assertError(validate(array(array(boolean)))([[true, 42]]))
+        },
+    },
+    record: {
+        empty: () => assertOk(validate(record(number))({})),
+        ok: () => {
+            const t = record(string)
+            /** @typedef {Assert<Equal<Ts<typeof t>, { readonly[K in string]?: string }>>} _RoundTrip */
+            assertOk(validate(t)({ a: 'hello', b: 'world' }))
+        },
+        error: () => {
+            assertError(validate(record(number))({ a: 1, b: 'two' }))
+            assertError(validate(record(number))(null))
+            assertError(validate(record(number))([]))
+        },
+    },
+    constThunk: {
+        primitive: () => {
+            const t = () => /** @type {const} */ (['const', 7n])
+            /** @typedef {Assert<Equal<Ts<typeof t>, 7n>>} _RoundTrip */
+            assertOk(validate(t)(7n))
+            assertError(validate(t)(8n))
+        },
+    },
+    or: {
+        consts: {
+            ok: () => {
+                const t = or(.../** @type {const} */ ([false,42, 'hello']))
+                /** @typedef {Assert<Equal<Ts<typeof t>, false | 42 | 'hello'>>} _RoundTrip */
+                assertOk(validate(t)(false))
+                assertOk(validate(t)(42))
+                assertOk(validate(t)('hello'))
+            },
+            error: () => {
+                const t = or(.../** @type {const} */ ([false, 42, 'hello']))
+                assertError(validate(t)(true))
+                assertError(validate(t)(43))
+                assertError(validate(t)('world'))
+                assertError(validate(t)(null))
+            },
+        },
+        thunks: {
+            ok: () => {
+                const t = or(number, string)
+                /** @typedef {Assert<Equal<Ts<typeof t>, number | string>>} _RoundTrip */
+                assertOk(validate(t)(42))
+                assertOk(validate(t)('hello'))
+            },
+            error: () => {
+                const t = or(number, string)
+                assertError(validate(t)(true))
+                assertError(validate(t)(null))
+            },
+        },
+        mixed: {
+            ok: () => {
+                const t = or(/** @type {const} */ (42), string)
+                /** @typedef {Assert<Equal<Ts<typeof t>, 42 | string>>} _RoundTrip */
+                assertOk(validate(t)(42))
+                assertOk(validate(t)('hello'))
+            },
+            error: () => {
+                const t = or(/** @type {const} */ (42), string)
+                assertError(validate(t)(43))
+                assertError(validate(t)(null))
+            },
+        },
+    },
+    option: {
+        ok: () => {
+            const t = option(number)
+            /** @typedef {Assert<Equal<Ts<typeof t>, number | undefined>>} _RoundTrip */
+            assertOk(validate(t)(42))
+            assertOk(validate(t)(undefined))
+        },
+        error: () => {
+            const t = option(number)
+            assertError(validate(t)(null))
+            assertError(validate(t)('42'))
+        },
+    },
+    path: {
+        rootMismatch: () => assertErrorPath([])(validate(number)('not a number')),
+        arrayIndex: () => assertErrorPath(['1'])(validate(array(number))([1, 'two', 3])),
+        recordKey: () => {
+            const r = validate(record(number))({ a: 1, b: 'two', c: 3 })
+            // record iteration order matches Object.entries; 'b' is the failing key
+            assertErrorPath(['b'])(r)
+        },
+        nestedArray: () => assertErrorPath(['0', '1'])(
+            validate(array(array(number)))([[1, 'x'], [2, 3]])
+        ),
+        tupleIndex: () => assertErrorPath(['1'])(
+            validate(/** @type {const} */ ([number, number]))([1, 'two'])
+        ),
+        structKey: () => assertErrorPath(['b'])(
+            validate(/** @type {const} */ ({ a: number, b: number }))({ a: 1, b: 'two' })
+        ),
+        deepStruct: () => {
+            const schema = /** @type {const} */ ({ user: { name: string, age: number } })
+            const r = validate(schema)({ user: { name: 'A', age: 'old' } })
+            assertErrorPath(['user', 'age'])(r)
+        },
+        recursiveSchema: () => {
+            /** @typedef {readonly _A[]} _A */
+            const list = () => /** @type {const} */ (['array', list])
+            // [[[42]]] — innermost element 42 is a number, not an array
+            const r = validate(list)([/** @type {_A} */ (/** @type {unknown} */ ([[42]]))])
+            assertErrorPath(['0', '0', '0'])(r)
+        },
+        orRoot: () => assertErrorPath([])(validate(or(number, string))(true)),
+    },
+    recursive: {
+        arrayOfArrays: () => {
+            /** @typedef {readonly _A[]} _A */
+            // self-referential schema: an array whose elements are also arrays of the same type
+            const list = () => /** @type {const} */ (['array', list])
+            /** @typedef {Assert<Equal<_A, Ts<typeof list>>>} _RoundTripA */
+            const v = validate(list)
+            assertOk(v([]))
+            assertOk(v([[], []]))
+            assertOk(v([[[], []], []]))
+            assertError(v([42]))
+            assertError(v(null))
+        },
+        recordOfRecords: () => {
+            const tree = () => /** @type {const} */ (['record', tree])
+            /** @typedef {{ readonly[K in string]?: _A }} _A */
+            /** @typedef {Assert<Equal<_A, Ts<typeof tree>>>} _RoundTrip */
+            const v = validate(tree)
+            assertOk(v({}))
+            assertOk(v({ a: {}, b: { c: {} } }))
+            assertError(v({ a: 42 }))
+        },
+    },
+    funcParam: () => {
+        const paramSet0 = /** @type {const} */ (['hello', bigint])
+        const paramSet1 = /** @type {const} */ (['goodbye', string, 43])
+
+        const paramSet01 = or(paramSet0, paramSet1)
+
+        /** @typedef {Ts<typeof paramSet0>} _Param0 */
+        /** @typedef {Ts<typeof paramSet1>} _Param1 */
+        /** @typedef {Ts<typeof paramSet01>} _Param01 */
+
+        const v0 = validate(paramSet0)
+        const v1 = validate(paramSet1)
+
+        /** @template T @typedef {(...args: _Param0) => T} _F0 */
+        /** @template T @typedef {(...args: _Param1) => T} _F1 */
+
+        /**
+         * @template T
+         * @param {_F0<T>} f0
+         * @param {_F1<T>} f1
+         * @returns {(...args: _Param01) => T}
+         */
+        const func = (f0, f1) => (...args) => {
+            {
+                const [t, r] = v0(args)
+                if (t === 'ok') {
+                    return f0(...r)
+                }
+            }
+            {
+                const [t, r] = v1(args)
+                if (t === 'ok') {
+                    return f1(...r)
+                }
+            }
+            throw 'unreachable: args did not match any parameter set'
+        }
+
+        /** @type {(a: 'hello', b: bigint) => number} */
+        const f0 = (a, b) => 42
+        /** @type {(a: 'goodbye', b: string, c: 43) => number} */
+        const f1 = (a, b, c) => 13
+
+        /** @type {(...args: _Param01) => number} */
+        const x = func(f0, f1)
+
+        return () => {
+            assertEq(x('hello', 42n), 42)
+            assertEq(x('goodbye', 'world', 43), 13)
+        }
+    },
+    funcObj: () => {
+        const param0 = { a: 'hello', b: bigint }
+        const param1 = { a: 'goodbye', b: string, c: 43 }
+
+        const param01 = or(param0, param1)
+
+        /** @typedef {Ts<typeof param0>} _Param0 */
+        /** @typedef {Ts<typeof param1>} _Param1 */
+        /** @typedef {Ts<typeof param01>} _Param01 */
+
+        const v0 = validate(param0)
+        const v1 = validate(param1)
+
+        /** @template T @typedef {(args: _Param0) => T} _F0 */
+        /** @template T @typedef {(args: _Param1) => T} _F1 */
+
+        /**
+         * @template T
+         * @param {_F0<T>} f0
+         * @param {_F1<T>} f1
+         * @returns {(args: _Param01) => T}
+         */
+        const func = (f0, f1) => args => {
+            {
+                const [t, r] = v0(args)
+                if (t === 'ok') {
+                    return f0(r)
+                }
+            }
+            {
+                const [t, r] = v1(args)
+                if (t === 'ok') {
+                    return f1(r)
+                }
+            }
+            throw 'unreachable: args did not match any parameter set'
+        }
+
+        /** @type {(args: _Param0) => number} */
+        const f0 = args => Number(args.b) + args.a.length
+        /** @type {(args: _Param1) => number} */
+        const f1 = args => args.c
+
+        /** @type {(args: _Param01) => number} */
+        const x = func(f0, f1)
+
+        return () => {
+            assertEq(x({ a: 'hello', b: 42n }), 47)
+            assertEq(x({ a: 'goodbye', b: 'world', c: 43 }), 43)
+        }
+    }
+}

package/fjs/types/rtti/validate/types.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Type-level API for RTTI validation.
+ *
+ * @module
+ */
+export type { Path, Result, Validate, ValidationError } from '../common/types.ts';

package/fjs/types/rtti/validate/types.js

@@ -0,0 +1 @@
+export {};

package/fjs/types/sorted_list/module.f.d.mts

@@ -0,0 +1,43 @@
+/**
+ * Sorted immutable list helpers and merge operations.
+ *
+ * @module
+ */
+import type { Cmp } from '../function/compare/types.ts';
+import type { List } from '../list/types.ts';
+import type { ReduceOp, SortedList, _MergeReduce } from './types.ts';
+export type _SortedArray<T> = readonly T[];
+/** @import { ReduceOp, SortedList, TailReduce, _MergeReduce } from './types.ts' */
+/** @template T @typedef {readonly T[]} _SortedArray */
+/**
+ * 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.
+ * `tailReduce` drains the non-exhausted list with current state once the other ends.
+ */
+export declare const genericMerge: <T, S>({ reduceOp, tailReduce }: _MergeReduce<T, S>) => (state: S) => (a: List<T>) => (b: List<T>) => List<T>;
+export type _CmpReduceOp<T> = ReduceOp<T, null>;
+/** @template T @typedef {ReduceOp<T, null>} _CmpReduceOp */
+export declare const merge: <T>(
+/**
+ * @template T
+ * @param {Cmp<T>} cmp
+ * @returns {(a: SortedList<T>) => (b: SortedList<T>) => SortedList<T>}
+ */
+cmp: Cmp<T>) => (a: SortedList<T>) => (b: SortedList<T>) => SortedList<T>;
+export declare const intersect: <T>(
+/**
+ * @template T
+ * @param {Cmp<T>} cmp
+ * @returns {(a: SortedList<T>) => (b: SortedList<T>) => SortedList<T>}
+ */
+cmp: Cmp<T>) => (a: SortedList<T>) => (b: SortedList<T>) => SortedList<T>;
+export declare const find: <T>(
+/**
+ * @template T
+ * @param {Cmp<T>} cmp
+ */
+cmp: Cmp<T>) => (
+/** @param {T} value */
+value: T) => (
+/** @param {_SortedArray<T>} array */
+array: _SortedArray<T>) => T | null;

package/fjs/types/sorted_list/module.f.mjs

@@ -0,0 +1,110 @@
+/**
+ * Sorted immutable list helpers and merge operations.
+ *
+ * @module
+ */
+
+import { bsearch } from '../function/compare/module.f.mjs'
+/** @import { Cmp } from '../function/compare/types.ts' */
+import { next } from '../list/module.f.mjs'
+/** @import { List } from '../list/types.ts' */
+import { identity } from '../function/module.f.mjs'
+/** @import { ReduceOp, SortedList, TailReduce, _MergeReduce } from './types.ts' */
+
+/** @template T @typedef {readonly T[]} _SortedArray */
+
+/**
+ * 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.
+ * `tailReduce` drains the non-exhausted list with current state once the other ends.
+ */
+export const genericMerge =
+    /**
+     * @template T
+     * @template S
+     * @param {_MergeReduce<T, S>} _
+     * @returns {(state: S) => (a: List<T>) => (b: List<T>) => List<T>}
+     */
+    ({ reduceOp, tailReduce }) => {
+        /** @param {S} state */
+        const f = state =>
+            /** @param {List<T>} a */
+            a =>
+            /** @param {List<T>} b */
+            b => () => {
+                const aResult = next(a)
+                if (aResult === null) { return tailReduce(state)(b) }
+                const bResult = next(b)
+                if (bResult === null) { return tailReduce(state)(aResult) }
+                const [first, sign, stateNext] = reduceOp(state)(aResult.first)(bResult.first)
+                const aNext = sign === 1 ? a : aResult.tail
+                const bNext = sign === -1 ? b : bResult.tail
+                const tail = f(stateNext)(aNext)(bNext)
+                return first === null ? tail : { first, tail }
+            }
+        return f
+    }
+
+/** @template T @typedef {ReduceOp<T, null>} _CmpReduceOp */
+
+export const merge =
+    /**
+     * @template T
+     * @param {Cmp<T>} cmp
+     * @returns {(a: SortedList<T>) => (b: SortedList<T>) => SortedList<T>}
+     */
+    cmp => {
+        /** @type {TailReduce<T, null>} */
+        const tailReduce = mergeTail
+        return genericMerge({ reduceOp: cmpReduce(cmp), tailReduce })(null)
+    }
+
+const cmpReduce =
+    /**
+     * @template T
+     * @param {Cmp<T>} cmp
+     * @returns {_CmpReduceOp<T>}
+     */
+    cmp => () => a => b => {
+        const sign = cmp(a)(b)
+        return [sign === 1 ? b : a, sign, null]
+    }
+
+/** @type {() => <T>(tail: List<T>) => List<T>} */
+const mergeTail = () => identity
+
+const tailReduce = () => () => null
+
+const intersectReduce =
+    /**
+     * @template T
+     * @param {Cmp<T>} cmp
+     * @returns {ReduceOp<T, null>}
+     */
+    cmp => () => a => b => {
+        const sign = cmp(a)(b)
+        return [sign === 0 ? a : null, sign, null]
+    }
+
+export const intersect =
+    /**
+     * @template T
+     * @param {Cmp<T>} cmp
+     * @returns {(a: SortedList<T>) => (b: SortedList<T>) => SortedList<T>}
+     */
+    cmp => genericMerge({ reduceOp: intersectReduce(cmp), tailReduce })(null)
+
+export const find =
+    /**
+     * @template T
+     * @param {Cmp<T>} cmp
+     */
+    cmp =>
+        /** @param {T} value */
+        value =>
+            /** @param {_SortedArray<T>} array */
+            array => {
+                const cmpValue = cmp(value)
+                const pos = bsearch(array.length)(mid => cmpValue(array[mid]))
+                return pos < array.length && cmpValue(array[pos]) === 0 ? value : null
+            }

package/fjs/types/sorted_list/proof.f.d.mts

@@ -0,0 +1,5 @@
+/** @import { Unknown } from '../../media/json/types.ts' */
+export declare const proof: {
+    sortedMergre: (() => void)[];
+    find: (() => void)[];
+};

package/fjs/types/sorted_list/proof.f.mjs

@@ -0,0 +1,52 @@
+/** @import { Unknown } from '../../media/json/types.ts' */
+
+import { find, merge } from './module.f.mjs'
+import { stringify } from '../../media/json/module.f.mjs'
+import { sort } from '../object/module.f.mjs'
+import { toArray, countdown, length } from '../list/module.f.mjs'
+import { flip } from '../function/module.f.mjs'
+import { cmp } from '../number/module.f.mjs'
+import { assert, assertEq } from '../../asserts/module.f.mjs'
+
+/** @type {(a: readonly Unknown[]) => string} */
+const str = stringify(sort)
+
+const reverseCmp = flip(cmp)
+
+export const proof = {
+    sortedMergre: [
+        () => {
+            const result = str(toArray(merge(cmp)([2, 3, 4])([1, 3, 5])))
+            assertEq(result, '[1,2,3,4,5]')
+        },
+        () => {
+            const result = str(toArray(merge(cmp)([1, 2, 3])([])))
+            assertEq(result, '[1,2,3]')
+        },
+        () => {
+            const n = 10_000
+            const list = countdown(n)
+            const result = merge(reverseCmp)(list)(list)
+            const len = length(result)
+            assert(len == n, result)
+        }
+    ],
+    find: [
+        () => {
+            const result = find(cmp)(0)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90])
+            assertEq(result, 0)
+        },
+        () => {
+            const result = find(cmp)(3)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90])
+            assertEq(result, null)
+        },
+        () => {
+            const result = find(cmp)(77)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90])
+            assertEq(result, null)
+        },
+        () => {
+            const result = find(cmp)(80)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90])
+            assertEq(result, 80)
+        }
+    ]
+}

package/fjs/types/sorted_list/types.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Types for sorted immutable lists and their merge operations.
+ *
+ * @module
+ */
+import type { Sign } from '../function/compare/types.ts';
+import type { List } from '../list/types.ts';
+import type { Nullable } from '../nullable/types.ts';
+export type SortedList<T> = List<T>;
+export type ReduceOp<T, S> = (state: S) => (a: T) => (b: T) => readonly [Nullable<T>, Sign, S];
+export type TailReduce<T, S> = (state: S) => (tail: List<T>) => List<T>;
+export type _MergeReduce<T, S> = {
+    readonly reduceOp: ReduceOp<T, S>;
+    readonly tailReduce: TailReduce<T, S>;
+};

package/fjs/types/sorted_list/types.js

@@ -0,0 +1,6 @@
+/**
+ * Types for sorted immutable lists and their merge operations.
+ *
+ * @module
+ */
+export {};