functionalscript 0.43.1 → 0.45.0

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

@@ -0,0 +1,127 @@
+/**
+ * Utility functions and types for managing and merging range maps.
+ *
+ * @module
+ *
+ * @example
+ *
+ * ```js
+ * const rmOps = rangeMap({
+ *     union: a => b => a | b,
+ *     equal: a => b => a === b,
+ *     def: 0,
+ * })
+ *
+ * // Create range maps
+ * const range1 = rmOps.fromRange(2)([0, 10])
+ * const range2 = rmOps.fromRange(5)([5, 15])
+ *
+ * // Merge range maps
+ * const merged = toArray(rmOps.merge(range1)(range2))
+ *
+ * // Retrieve values from the merged range map
+ * const get = rmOps.get(merged)
+ * //
+ * if (get(-1) !== 0) { throw 'error' }
+ * //
+ * if (get(0) !== 2) { throw 'error' }
+ * if (get(2) !== 2) { throw 'error' }
+ * // overlapped: 2 | 5 = 7
+ * if (get(7) !== 7) { throw 'error' }
+ * //
+ * if (get(12) !== 5) { throw 'error' }
+ * if (get(15) !== 5) { throw 'error' }
+ * //
+ * if (get(16) !== 0) { throw 'error' }
+ * ```
+ *
+ * @import { TailReduce, ReduceOp } from '../sorted_list/types.ts'
+ * @import { Nullable } from '../nullable/types.ts'
+ * @import { Equal } from '../function/operator/types.ts'
+ * @import { Range } from '../range/types.ts'
+ * @import { Entry, Properties, RangeMapArray, RangeMapOp, RangeMerge, } from './types.ts'
+ */
+
+import { genericMerge } from '../sorted_list/module.f.mjs'
+import { next } from '../list/module.f.mjs'
+import { cmp } from '../number/module.f.mjs'
+import { bsearch } from '../function/compare/module.f.mjs'
+
+/** @template T @typedef {Nullable<Entry<T>>} _RangeState */
+
+const reduceOp =
+    /**
+     * @template T
+     * @param {Properties<T>} p
+     * @returns {ReduceOp<Entry<T>, _RangeState<T>>}
+     */
+    ({ union, equal }) => state => ([aItem, aMax]) => ([bItem, bMax]) => {
+        const sign = cmp(aMax)(bMax)
+        const min = sign === 1 ? bMax : aMax
+        const u = union(aItem)(bItem)
+        const newState = state !== null && equal(state[0])(u) ? null : state
+        return [newState, sign, [u, min]]
+    }
+
+const tailReduce =
+    /**
+     * @template T
+     * @param {Equal<T>} equal
+     * @returns {TailReduce<Entry<T>, _RangeState<T>>}
+     */
+    equal => state => tail => {
+        if (state === null) { return tail }
+        const tailResult = next(tail)
+        if (tailResult === null) { return [state] }
+        if (equal(state[0])(tailResult.first[0])) { return tailResult }
+        return { first: state, tail: tailResult }
+    }
+
+export const merge =
+    /**
+     * @template T
+     * @param {Properties<T>} op
+     * @returns {RangeMerge<T>}
+     */
+    op => genericMerge({ reduceOp: reduceOp(op), tailReduce: tailReduce(op.equal) })(null)
+
+export const get =
+    /**
+     * @template T
+     * @param {T} def
+     */
+    def =>
+        /** @param {RangeMapArray<T>} rm */
+        rm => {
+            const length = rm.length
+            const search = bsearch(length)
+            /** @param {number} value */
+            return value => {
+                const pos = search(mid => value <= rm[mid][1] ? -1 : 1)
+                return pos < length ? rm[pos][0] : def
+            }
+        }
+
+export const fromRange =
+    /**
+     * @template T
+     * @param {T} def
+     */
+    def =>
+        /** @param {T} v */
+        v =>
+            /** @param {Range} r */
+            ([a, b]) => /** @type {RangeMapArray<T>} */([[def, a - 1], [v, b]])
+
+/**
+ * Creates a set of operations for managing range maps using the specified properties.
+ *
+ * @template T
+ * @param {Properties<T>} op The properties defining union and equality operations and the default value.
+ * @returns {RangeMapOp<T>} An object containing operations for merging, retrieving, and constructing range maps.
+ */
+export const rangeMap = op => ({
+    merge: merge(op),
+    get: get(op.def),
+    fromRange: fromRange(op.def),
+})

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

@@ -0,0 +1,11 @@
+/**
+ * @import { Unknown } from '../../media/json/types.ts'
+ * @import { RangeMapArray, Properties, RangeMap } from './types.ts'
+ * @import { SortedSet } from '../sorted_set/types.ts'
+ */
+export declare const proof: {
+    example: () => void;
+    merge: (() => void)[];
+    get: () => (() => void)[];
+    fromRange: () => (() => void)[];
+};

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

@@ -0,0 +1,188 @@
+/**
+ * @import { Unknown } from '../../media/json/types.ts'
+ * @import { RangeMapArray, Properties, RangeMap } from './types.ts'
+ * @import { SortedSet } from '../sorted_set/types.ts'
+ */
+
+import { get, merge, fromRange, rangeMap } from './module.f.mjs'
+import { stringify } from '../../media/json/module.f.mjs'
+import { sort } from '../object/module.f.mjs'
+import { union } from '../sorted_set/module.f.mjs'
+import { equal, toArray } from '../list/module.f.mjs'
+import { strictEqual } from '../function/operator/module.f.mjs'
+import { cmp } from '../string/module.f.mjs'
+import { assertEq } from '../../asserts/module.f.mjs'
+
+/** @type {(a: readonly Unknown[]) => string} */
+const str = stringify(sort)
+
+/** @type {Properties<SortedSet<string>>} */
+const op = {
+    union: union(cmp),
+    equal: equal(strictEqual),
+    def: []
+}
+
+export const proof = {
+    example: () => {
+        const rmOps = rangeMap({
+            union: a => b => a | b,
+            equal: a => b => a === b,
+            def: 0,
+        })
+
+        // Create range maps
+        const range1 = rmOps.fromRange(2)([0, 10])
+        const range2 = rmOps.fromRange(5)([5, 15])
+
+        // Merge range maps
+        const merged = toArray(rmOps.merge(range1)(range2))
+
+        // Retrieve values from the merged range map
+        //
+        const get = rmOps.get(merged)
+        assertEq(get(-1), 0, 'error')
+        //
+        assertEq(get(0), 2, 'error')
+        assertEq(get(2), 2, 'error')
+        // 2 | 5 = 7
+        assertEq(get(7), 7, 'error')
+        //
+        assertEq(get(12), 5, 'error')
+        assertEq(get(15), 5, 'error')
+        //
+        assertEq(get(16), 0, 'error')
+    },
+    merge: [
+        () => {
+            /** @type {RangeMap<SortedSet<string>>} */
+            const a = [[['a'], 1], [['b'], 2]]
+            /** @type {RangeMap<SortedSet<string>>} */
+            const b = null
+            const merged = merge(op)(a)(b)
+            const result = str(toArray(merged))
+            assertEq(result, '[[["a"],1],[["b"],2]]')
+        },
+        () => {
+            /** @type {RangeMap<SortedSet<string>>} */
+            const a = null
+            /** @type {RangeMap<SortedSet<string>>} */
+            const b = [[['a'], 1], [['b'], 2]]
+            const merged = merge(op)(a)(b)
+            const result = str(toArray(merged))
+            assertEq(result, '[[["a"],1],[["b"],2]]')
+        },
+        () => {
+            /** @type {RangeMap<SortedSet<string>>} */
+            const a = [[['a'], 1], [['b'], 2]]
+            /** @type {RangeMap<SortedSet<string>>} */
+            const b = [[['a'], 1], [['b'], 2]]
+            const merged = merge(op)(a)(b)
+            const result = str(toArray(merged))
+            assertEq(result, '[[["a"],1],[["b"],2]]')
+        },
+        () => {
+            /** @type {RangeMap<SortedSet<string>>} */
+            const a = [[['a'], 1], [['c'], 3]]
+            /** @type {RangeMap<SortedSet<string>>} */
+            const b = [[['b'], 2], [['d'], 4]]
+            const merged = merge(op)(a)(b)
+            const result = str(toArray(merged))
+            assertEq(result, '[[["a","b"],1],[["b","c"],2],[["c","d"],3],[["d"],4]]')
+        },
+        () => {
+            /** @type {RangeMap<SortedSet<string>>} */
+            const a = [[['a'], 1], [['d'], 4]]
+            /** @type {RangeMap<SortedSet<string>>} */
+            const b = [[['b'], 2], [['c'], 3]]
+            const merged = merge(op)(a)(b)
+            const result = str(toArray(merged))
+            assertEq(result, '[[["a","b"],1],[["b","d"],2],[["c","d"],3],[["d"],4]]')
+        },
+        () => {
+            /** @type {RangeMap<SortedSet<string>>} */
+            const a = [[['a'], 1], [['b'], 2]]
+            /** @type {RangeMap<SortedSet<string>>} */
+            const b = [[['b'], 1], [['a'], 2]]
+            const merged = merge(op)(a)(b)
+            const result = str(toArray(merged))
+            assertEq(result, '[[["a","b"],2]]')
+        },
+        () => {
+            /** @type {RangeMap<SortedSet<string>>} */
+            const a = [[['a'], 1], [['b'], 2], [['a'], 3]]
+            /** @type {RangeMap<SortedSet<string>>} */
+            const b = [[['a'], 5]]
+            const merged = merge(op)(a)(b)
+            const result = str(toArray(merged))
+            assertEq(result, '[[["a"],1],[["a","b"],2],[["a"],5]]')
+        }
+    ],
+    get: () => {
+        /** @type {SortedSet<string>} */
+        const sortedSetEmpty = []
+        const at = get(sortedSetEmpty)
+        return [
+            () => {
+                /** @type {RangeMapArray<SortedSet<string>>} */
+                const rm = [[['a'], 10], [['b'], 20], [['c'], 30]]
+                const result = str(at(rm)(5))
+                assertEq(result, '["a"]')
+            },
+            () => {
+                /** @type {RangeMapArray<SortedSet<string>>} */
+                const rm = [[['a'], 10], [['b'], 20], [['c'], 30]]
+                const result = str(at(rm)(10))
+                assertEq(result, '["a"]')
+            },
+            () => {
+                /** @type {RangeMapArray<SortedSet<string>>} */
+                const rm = [[['a'], 10], [['b'], 20], [['c'], 30]]
+                const result = str(at(rm)(15))
+                assertEq(result, '["b"]')
+            },
+            () => {
+                /** @type {RangeMapArray<SortedSet<string>>} */
+                const rm = [[['a'], 10], [['b'], 20], [['c'], 30]]
+                const result = str(at(rm)(20))
+                assertEq(result, '["b"]')
+            },
+            () => {
+                /** @type {RangeMapArray<SortedSet<string>>} */
+                const rm = [[['a'], 10], [['b'], 20], [['c'], 30]]
+                const result = str(at(rm)(25))
+                assertEq(result, '["c"]')
+            },
+            () => {
+                /** @type {RangeMapArray<SortedSet<string>>} */
+                const rm = [[['a'], 10], [['b'], 20], [['c'], 30]]
+                const result = str(at(rm)(30))
+                assertEq(result, '["c"]')
+            },
+            () => {
+                /** @type {RangeMapArray<SortedSet<string>>} */
+                const rm = [[['a'], 10], [['b'], 20], [['c'], 30]]
+                const result = str(at(rm)(35))
+                assertEq(result, '[]')
+            },
+            () => {
+                /** @type {RangeMapArray<SortedSet<string>>} */
+                const rm = []
+                const result = str(at(rm)(10))
+                assertEq(result, '[]')
+            }
+        ]
+    },
+    fromRange: () => {
+        const def = -1
+        const rm = fromRange(def)(42)([1, 7])
+        const g = get(def)(rm)
+        return [
+            () => assertEq(g(0), -1),
+            () =>assertEq(g(1), 42),
+            () => assertEq(g(3), 42),
+            () =>assertEq(g(7), 42),
+            () => assertEq(g(9), -1),
+        ]
+    },
+}

package/fjs/types/range_map/types.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Types for managing and merging range maps.
+ *
+ * @module
+ */
+import type { Equal, Reduce } from '../function/operator/types.ts';
+import type { Range } from '../range/types.ts';
+import type { SortedList } from '../sorted_list/types.ts';
+export type Entry<T> = [T, number];
+/**
+ * A sorted list of entries, where each entry is a tuple `[T, number]` that maps
+ * a value of type `T` to an upper boundary of a numeric range.
+ */
+export type RangeMap<T> = SortedList<Entry<T>>;
+export type RangeMapArray<T> = readonly Entry<T>[];
+/**
+ * Defines the properties and operations required for managing range maps.
+ *
+ * @property union
+ *
+ * A function to merge two values of type `T`. This defines how overlapping ranges are combined.
+ *
+ * @property equal
+ *
+ * A function to check equality between two values of type `T`.
+ *
+ * @property def
+ *
+ * The default value used when no range matches or for initializing ranges.
+ */
+export type Properties<T> = {
+    readonly union: Reduce<T>;
+    readonly equal: Equal<T>;
+    readonly def: T;
+};
+export type RangeMerge<T> = Reduce<RangeMap<T>>;
+/**
+ * Represents a set of operations for managing range maps.
+ *
+ * @property merge
+ *
+ * Merges two range maps into a single range map.
+ *
+ * @property get
+ *
+ * Retrieves the value associated with a given numeric range.
+ *
+ * @property fromRange
+ *
+ * Constructs a range map for a single numeric range and value.
+ */
+export type RangeMapOp<T> = {
+    readonly merge: RangeMerge<T>;
+    readonly get: (rm: RangeMapArray<T>) => (value: number) => T;
+    readonly fromRange: (value: T) => (r: Range) => RangeMapArray<T>;
+};

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

@@ -0,0 +1,10 @@
+/**
+ * A set of numeric ranges, represented as a `range_map` of `boolean`.
+ *
+ * @module
+ */
+/**
+ * Constructs a range set containing a single numeric range.
+ */
+export declare const fromRange: (r: import("../range/types.ts").Range) => import("../range_map/types.ts").RangeMapArray<boolean>;
+export declare const merge: import("../range_map/types.ts").RangeMerge<boolean>, get: (rm: import("../range_map/types.ts").RangeMapArray<boolean>) => (value: number) => boolean;

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

@@ -0,0 +1,20 @@
+/**
+ * A set of numeric ranges, represented as a `range_map` of `boolean`.
+ *
+ * @module
+ */
+
+import { rangeMap } from '../range_map/module.f.mjs'
+
+const map = rangeMap({
+    union: a => b => a || b,
+    equal: a => b => a === b,
+    def: false,
+})
+
+/**
+ * Constructs a range set containing a single numeric range.
+ */
+export const fromRange = map.fromRange(true)
+
+export const { merge, get } = map

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

@@ -0,0 +1,4 @@
+/**
+ * @import { Range } from '../range/types.ts'
+ */
+export declare const proof: () => void;

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

@@ -0,0 +1,29 @@
+/**
+ * @import { Range } from '../range/types.ts'
+ */
+
+import { assert } from '../../asserts/module.f.mjs'
+import { toArray } from '../list/module.f.mjs'
+import { fromRange, merge, get } from './module.f.mjs'
+
+/** @type {(a: string) => number} */
+const c = a => a.charCodeAt(0)
+
+/** @type {(_: string) => Range} */
+const range = ([a, b]) => [c(a), c(b)]
+
+export const proof = () => {
+    const digit = fromRange(range('09'))
+    const initial = toArray(merge
+        (fromRange(range('AZ')))
+        (fromRange(range('az'))))
+    const isInitial = get(initial)
+    assert(!isInitial(0))
+    assert(isInitial(c('a')))
+    assert(!isInitial(c('1')))
+    assert(isInitial(c('Z')))
+    const isNext = get(toArray(merge(initial)(digit)))
+    assert(isNext(c('0')))
+    assert(isNext(c('A')))
+    assert(!isNext(c('@')))
+}

package/fjs/types/result/module.d.mts

@@ -0,0 +1,13 @@
+/**
+ * Impure `Result` companions: capture thrown exceptions as `Result` values,
+ * since `try`/`catch` is not allowed in FunctionalScript itself.
+ *
+ * @module
+ *
+ * @import { Result } from './types.ts'
+ */
+import type { Result } from './types.ts';
+/** @type {<T>(f: () => T) => Result<T, unknown>} */
+export declare const tryCatch: <T>(f: () => T) => Result<T, unknown>;
+/** @type {<T>(f: () => Promise<T>) => Promise<Result<T, unknown>>} */
+export declare const asyncTryCatch: <T>(f: () => Promise<T>) => Promise<Result<T, unknown>>;

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

@@ -0,0 +1,89 @@
+/**
+ * A module for representing and handling operations that can succeed or fail.
+ *
+ * @module
+ *
+ * @example
+ *
+ * ```js
+ * import { error, ok, okThen, unwrap } from './module.f.mjs'
+ *
+ * const success = ok(42)
+ * const failure = error('Something went wrong')
+ *
+ * if (unwrap(success) !== 42) { throw 'error' }
+ * const [kind, v] = failure
+ * if (kind !== 'error') { throw 'error' }
+ * // `v` is `'Something went wrong'` here
+ *
+ * // `okThen` chains; an `error` skips the rest of the chain unchanged.
+ * const half = n => n % 2 === 0 ? ok(n / 2) : error('odd')
+ * if (unwrap(okThen(half)(success)) !== 21) { throw 'error' }
+ * ```
+ *
+ * @import { Ok, Error, Result } from './types.ts'
+ */
+import type { Ok, Error, Result } from './types.ts';
+/**
+ * Creates a successful result.
+ *
+ * @template T
+ * @param {T} value - The value to wrap.
+ * @returns {Ok<T>} A successful result containing the value.
+ */
+export declare const ok: <T>(value: T) => Ok<T>;
+/**
+ * Creates a failed result.
+ *
+ * @template E
+ * @param {E} e - The error to wrap.
+ * @returns {Error<E>} A failed result containing the error.
+ */
+export declare const error: <E>(e: E) => Error<E>;
+/**
+ * Unwraps a result, returning the value if successful or throwing the error if failed.
+ *
+ * @template T
+ * @template E
+ * @param {Result<T, E>} param0 - The result to unwrap.
+ * @returns {T} The value if the result is successful. Otherwise, throws the error.
+ */
+export declare const unwrap: <T, E>([kind, v]: Result<T, E>) => T;
+/**
+ * Swaps the `ok` and `error` cases of a result.
+ *
+ * @type {<T, E>([k, v]: Result<T, E>) => Result<E, T>}
+ */
+export declare const invert: <T, E>([k, v]: Result<T, E>) => Result<E, T>;
+/**
+ * Maps the `ok` case of a result, passing an `error` through unchanged.
+ *
+ * @type {<T, R>(f: (value: T) => R) => <E>(r: Result<T, E>) => Result<R, E>}
+ */
+export declare const mapOk: <T, R>(f: (value: T) => R) => <E>(r: Result<T, E>) => Result<R, E>;
+/**
+ * Chains a `Result`-returning step onto a `Result`, passing an `error` through
+ * unchanged. The monadic bind to {@link mapOk}'s functor map, and the pure
+ * sibling of `fjs/effects`' `okStep` — which is the same combinator for a step
+ * that also performs operations.
+ *
+ * The two error types are **unioned, not unified**. A validation chain
+ * typically widens its error as it goes — a JSON parse failure (`string`)
+ * followed by an rtti schema failure (`ValidationError`) — and the hand-written
+ * form expressed that by rebuilding the incoming error with `error(v)` purely
+ * to retag it into the wider type. `E | F` states the widening in the type
+ * instead, so neither side has to be pre-widened and the passed-through
+ * `error` stays the very tuple it arrived as.
+ *
+ * `F` binds on the second arrow, as in {@link mapOk}: `f` alone determines the
+ * value types, so one `okThen(f)` applies to results carrying any error type.
+ *
+ * Reach for it when the step needs **only** the value it is handed. A chain
+ * whose later steps also read an earlier one's value would have to nest a
+ * closure per link to keep those values in scope, which AGENTS.md §6.4 rules
+ * out for the same reason it rules out nested `step`; write those as a flat
+ * sequence of guards.
+ *
+ * @type {<T, R, E>(f: (value: T) => Result<R, E>) => <F>(r: Result<T, F>) => Result<R, E | F>}
+ */
+export declare const okThen: <T, R, E>(f: (value: T) => Result<R, E>) => <F>(r: Result<T, F>) => Result<R, E | F>;

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

@@ -0,0 +1,97 @@
+/**
+ * A module for representing and handling operations that can succeed or fail.
+ *
+ * @module
+ *
+ * @example
+ *
+ * ```js
+ * import { error, ok, okThen, unwrap } from './module.f.mjs'
+ *
+ * const success = ok(42)
+ * const failure = error('Something went wrong')
+ *
+ * if (unwrap(success) !== 42) { throw 'error' }
+ * const [kind, v] = failure
+ * if (kind !== 'error') { throw 'error' }
+ * // `v` is `'Something went wrong'` here
+ *
+ * // `okThen` chains; an `error` skips the rest of the chain unchanged.
+ * const half = n => n % 2 === 0 ? ok(n / 2) : error('odd')
+ * if (unwrap(okThen(half)(success)) !== 21) { throw 'error' }
+ * ```
+ *
+ * @import { Ok, Error, Result } from './types.ts'
+ */
+
+/**
+ * Creates a successful result.
+ *
+ * @template T
+ * @param {T} value - The value to wrap.
+ * @returns {Ok<T>} A successful result containing the value.
+ */
+export const ok = value  => ['ok', value]
+
+/**
+ * Creates a failed result.
+ *
+ * @template E
+ * @param {E} e - The error to wrap.
+ * @returns {Error<E>} A failed result containing the error.
+ */
+export const error = e => ['error', e]
+
+/**
+ * Unwraps a result, returning the value if successful or throwing the error if failed.
+ *
+ * @template T
+ * @template E
+ * @param {Result<T, E>} param0 - The result to unwrap.
+ * @returns {T} The value if the result is successful. Otherwise, throws the error.
+ */
+export const unwrap = ([kind, v]) => {
+    if (kind === 'error') { throw v }
+    return v
+}
+
+/**
+ * Swaps the `ok` and `error` cases of a result.
+ *
+ * @type {<T, E>([k, v]: Result<T, E>) => Result<E, T>}
+ */
+export const invert = ([k, v]) => k === 'ok' ? error(v) : ok(v)
+
+/**
+ * Maps the `ok` case of a result, passing an `error` through unchanged.
+ *
+ * @type {<T, R>(f: (value: T) => R) => <E>(r: Result<T, E>) => Result<R, E>}
+ */
+export const mapOk = f => r => r[0] === 'ok' ? ok(f(r[1])) : r
+
+/**
+ * Chains a `Result`-returning step onto a `Result`, passing an `error` through
+ * unchanged. The monadic bind to {@link mapOk}'s functor map, and the pure
+ * sibling of `fjs/effects`' `okStep` — which is the same combinator for a step
+ * that also performs operations.
+ *
+ * The two error types are **unioned, not unified**. A validation chain
+ * typically widens its error as it goes — a JSON parse failure (`string`)
+ * followed by an rtti schema failure (`ValidationError`) — and the hand-written
+ * form expressed that by rebuilding the incoming error with `error(v)` purely
+ * to retag it into the wider type. `E | F` states the widening in the type
+ * instead, so neither side has to be pre-widened and the passed-through
+ * `error` stays the very tuple it arrived as.
+ *
+ * `F` binds on the second arrow, as in {@link mapOk}: `f` alone determines the
+ * value types, so one `okThen(f)` applies to results carrying any error type.
+ *
+ * Reach for it when the step needs **only** the value it is handed. A chain
+ * whose later steps also read an earlier one's value would have to nest a
+ * closure per link to keep those values in scope, which AGENTS.md §6.4 rules
+ * out for the same reason it rules out nested `step`; write those as a flat
+ * sequence of guards.
+ *
+ * @type {<T, R, E>(f: (value: T) => Result<R, E>) => <F>(r: Result<T, F>) => Result<R, E | F>}
+ */
+export const okThen = f => r => r[0] === 'error' ? r : f(r[1])

package/fjs/types/result/module.mjs

@@ -0,0 +1,30 @@
+/**
+ * Impure `Result` companions: capture thrown exceptions as `Result` values,
+ * since `try`/`catch` is not allowed in FunctionalScript itself.
+ *
+ * @module
+ *
+ * @import { Result } from './types.ts'
+ */
+
+import { ok, error } from './module.f.mjs'
+
+/** @type {<T>(f: () => T) => Result<T, unknown>} */
+export const tryCatch = f => {
+    // Side effect: `try catch` is not allowed in FunctionalScript.
+    try {
+        return ok(f())
+    } catch (e) {
+        return error(e)
+    }
+}
+
+/** @type {<T>(f: () => Promise<T>) => Promise<Result<T, unknown>>} */
+export const asyncTryCatch = async f => {
+    // Side effect: `try catch` is not allowed in FunctionalScript.
+    try {
+        return ok(await f())
+    } catch (e) {
+        return error(e)
+    }
+}