functionalscript 0.44.0 → 0.46.0

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

@@ -1,20 +1,29 @@
 /**
- * Plain-object helpers: safe property lookup via `at`, and conversions
- * between entries and `OrderedMap`. See `./types.ts` for the
+ * Plain-object helpers: safe property lookup via `at`, structural comparison
+ * via `structurallySame`, and conversions between entries and `OrderedMap`.
+ * See `./types.ts` for the
  * `OptionalMap`/`RequiredMap`/`StringMap`/`Entry`/`OneKey`/`SingleProperty`/
  * `NotUnion` type-level API.
  *
  * @module
+ *
+ * @import { List } from '../list/types.ts'
+ * @import { Nullable } from '../nullable/types.ts'
+ * @import { OrderedMap } from '../ordered_map/types.ts'
+ * @import { StringMap, Entry } from './types.ts'
  */
 
 import { isArray } from '../array/module.f.mjs'
 import { iterable } from '../list/module.f.mjs'
-/** @import { List } from '../list/types.ts' */
 import { fromUndefined } from '../nullable/module.f.mjs'
-/** @import { Nullable } from '../nullable/types.ts' */
 import { entries as mapEntries, fromEntries as mapFromEntries } from '../ordered_map/module.f.mjs'
-/** @import { OrderedMap } from '../ordered_map/types.ts' */
-/** @import { StringMap, Entry } from './types.ts' */
+
+/**
+ * `structurallySame` is implemented in a dependency-free leaf so `fjs/asserts`
+ * can use it without the cycle `asserts -> object -> nullable -> asserts`; see
+ * `./structurally_same/README.md`. This module is its public home.
+ */
+export { structurallySame } from './structurally_same/module.f.mjs'
 
 const { getOwnPropertyDescriptor, fromEntries: objectFromEntries } = Object
 
@@ -52,7 +61,17 @@ export const definedValues =
     map =>
     values(map).filter(v => v !== undefined)
 
-/** @type {<T>(cmd: StringMap<Exclude<T, undefined>>) => readonly (readonly [string, Exclude<T, undefined>])[]} */
+/**
+ * Returns only the defined (non-undefined) entries of a partial record.
+ *
+ * `T` is the record's own value type, which `StringMap` already makes
+ * optional. Writing the parameter as `StringMap<Exclude<T, undefined>>`
+ * instead would leave `T` in a non-inference position, so a record whose value
+ * type is itself generic — the leaf-parameterized JSON tree, say — could not
+ * be passed at all.
+ *
+ * @type {<T>(cmd: StringMap<T>) => readonly Entry<T>[]}
+ */
 export const definedEntries =
     cmd =>
     entries(cmd).flatMap(([a, b]) => b === undefined ? [] : [[a, b]])

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

@@ -1,3 +1,8 @@
+/**
+ * @import { OptionalMap, RequiredMap, StringMap } from './types.ts'
+ * @import { Assert } from '../../asserts/types.ts'
+ * @import { Equal } from '../ts/types.ts'
+ */
 import type { OptionalMap, RequiredMap, StringMap } from './types.ts';
 import type { Assert } from '../../asserts/types.ts';
 import type { Equal } from '../ts/types.ts';
@@ -13,8 +18,6 @@ export type _RequiredIsRequired = Assert<Equal<RequiredMap<'a' | 'b', bigint>, {
     readonly b: bigint;
 }>>;
 export type _RequiredOverAnyStringIsNever = Assert<Equal<RequiredMap<string, bigint>, never>>;
-/** @import { Assert } from '../../asserts/types.ts' */
-/** @import { Equal } from '../ts/types.ts' */
 /** @typedef {Assert<Equal<StringMap<bigint>, { readonly [k in string]?: bigint }>>} _StringMapIsOptional */
 /** @typedef {Assert<Equal<OptionalMap<'a'|'b', bigint>, { readonly a?: bigint; readonly b?: bigint }>>} _OptionalIsPartial */
 /** @typedef {Assert<Equal<RequiredMap<'a'|'b', bigint>, { readonly a: bigint; readonly b: bigint }>>} _RequiredIsRequired */

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

@@ -1,8 +1,11 @@
+/**
+ * @import { OptionalMap, RequiredMap, StringMap } from './types.ts'
+ * @import { Assert } from '../../asserts/types.ts'
+ * @import { Equal } from '../ts/types.ts'
+ */
+
 import { at } from './module.f.mjs'
-/** @import { OptionalMap, RequiredMap, StringMap } from './types.ts' */
 import { assertEq } from '../../asserts/module.f.mjs'
-/** @import { Assert } from '../../asserts/types.ts' */
-/** @import { Equal } from '../ts/types.ts' */
 
 /** @typedef {Assert<Equal<StringMap<bigint>, { readonly [k in string]?: bigint }>>} _StringMapIsOptional */
 

package/fjs/types/object/structurally_same/module.f.d.mts

@@ -0,0 +1,39 @@
+/**
+ * Structural comparison for FunctionalScript data.
+ *
+ * `structurallySame` answers "do these two independently constructed values
+ * have the same shape and the same leaves?" — the question proofs really ask
+ * when they compare a computed value against an expected one. It is scoped to
+ * FunctionalScript data (primitives, arrays, and record-like objects) and
+ * deliberately says nothing about dates, maps, sets, typed arrays, prototypes,
+ * or property descriptors; see the README for what it does *not* promise.
+ *
+ * This module is a dependency-free leaf on purpose. `fjs/asserts` needs the
+ * comparison for `assertStructurallySame`, and the public object module
+ * (`../module.f.mjs`) reaches `fjs/asserts` through `types/nullable`, so
+ * importing anything here would close the cycle
+ * `asserts -> object -> nullable -> asserts`. Keep it importing nothing.
+ *
+ * @module
+ */
+/**
+ * Compares two values structurally.
+ *
+ * - `Object.is` decides first, so `NaN` equals itself, `0` and `-0` differ, and
+ *   an object is trivially the same as itself.
+ * - Anything else that is not a non-null object differs.
+ * - Arrays match arrays of the same length whose elements match pairwise; an
+ *   array never matches a non-array. Arrays are assumed dense — FunctionalScript
+ *   cannot build a sparse one; see the README.
+ * - Other objects match when their own enumerable string properties form the
+ *   same set — order is irrelevant — and every property's value matches. A
+ *   property whose value is `undefined` is a property: `{ a: undefined }` and
+ *   `{}` differ.
+ *
+ * There is no cycle detection: a self-referential value recurses until the
+ * stack runs out. FunctionalScript data is acyclic, and adding a seen-set would
+ * cost every ordinary comparison for a case that cannot arise.
+ *
+ * @type {(a: unknown, b: unknown) => boolean}
+ */
+export declare const structurallySame: (a: unknown, b: unknown) => boolean;

package/fjs/types/object/structurally_same/module.f.mjs

@@ -0,0 +1,59 @@
+/**
+ * Structural comparison for FunctionalScript data.
+ *
+ * `structurallySame` answers "do these two independently constructed values
+ * have the same shape and the same leaves?" — the question proofs really ask
+ * when they compare a computed value against an expected one. It is scoped to
+ * FunctionalScript data (primitives, arrays, and record-like objects) and
+ * deliberately says nothing about dates, maps, sets, typed arrays, prototypes,
+ * or property descriptors; see the README for what it does *not* promise.
+ *
+ * This module is a dependency-free leaf on purpose. `fjs/asserts` needs the
+ * comparison for `assertStructurallySame`, and the public object module
+ * (`../module.f.mjs`) reaches `fjs/asserts` through `types/nullable`, so
+ * importing anything here would close the cycle
+ * `asserts -> object -> nullable -> asserts`. Keep it importing nothing.
+ *
+ * @module
+ */
+
+const { entries, is } = Object
+
+/**
+ * Compares two values structurally.
+ *
+ * - `Object.is` decides first, so `NaN` equals itself, `0` and `-0` differ, and
+ *   an object is trivially the same as itself.
+ * - Anything else that is not a non-null object differs.
+ * - Arrays match arrays of the same length whose elements match pairwise; an
+ *   array never matches a non-array. Arrays are assumed dense — FunctionalScript
+ *   cannot build a sparse one; see the README.
+ * - Other objects match when their own enumerable string properties form the
+ *   same set — order is irrelevant — and every property's value matches. A
+ *   property whose value is `undefined` is a property: `{ a: undefined }` and
+ *   `{}` differ.
+ *
+ * There is no cycle detection: a self-referential value recurses until the
+ * stack runs out. FunctionalScript data is acyclic, and adding a seen-set would
+ * cost every ordinary comparison for a case that cannot arise.
+ *
+ * @type {(a: unknown, b: unknown) => boolean}
+ */
+export const structurallySame = (a, b) => {
+    if (is(a, b)) { return true }
+    if (
+        typeof a !== 'object' || a === null ||
+        typeof b !== 'object' || b === null
+    ) { return false }
+    if (a instanceof Array) {
+        return b instanceof Array
+            && a.length === b.length
+            && a.every((v, i) => structurallySame(v, b[i]))
+    }
+    if (b instanceof Array) { return false }
+    const ae = entries(a)
+    /** @type {ReadonlyMap<string, unknown>} */
+    const bm = new Map(entries(b))
+    return ae.length === bm.size
+        && ae.every(([k, v]) => bm.has(k) && structurallySame(v, bm.get(k)))
+}

package/fjs/types/object/structurally_same/proof.f.d.mts

@@ -0,0 +1,6 @@
+export declare const proof: {
+    primitives: (() => void)[];
+    identity: (() => void)[];
+    arrays: (() => void)[];
+    objects: (() => void)[];
+};

package/fjs/types/object/structurally_same/proof.f.mjs

@@ -0,0 +1,73 @@
+import { assert } from '../../../asserts/module.f.mjs'
+import { structurallySame } from './module.f.mjs'
+
+/** @type {(a: unknown, b: unknown) => void} */
+const same = (a, b) => assert(structurallySame(a, b), ['same', a, b])
+
+/** @type {(a: unknown, b: unknown) => void} */
+const differ = (a, b) => assert(!structurallySame(a, b), ['differ', a, b])
+
+export const proof = {
+    primitives: [
+        // `Object.is` decides, so `NaN` is its own equal...
+        () => same(Number.NaN, Number.NaN),
+        () => same(42, 42),
+        () => same('a', 'a'),
+        () => same(undefined, undefined),
+        () => same(null, null),
+        // ...and the two zeros are not.
+        () => differ(0, -0),
+        () => differ(1, 2),
+        () => differ('a', 'b'),
+        () => differ(null, undefined),
+        // a non-object on either side ends it
+        () => differ(1, {}),
+        () => differ({}, 1),
+        () => differ(null, {}),
+        () => differ({}, null),
+    ],
+    identity: [
+        // the same reference short-circuits before any traversal
+        () => {
+            const a = /** @type {const} */ ({ x: [1, 2] })
+            same(a, a)
+        },
+    ],
+    arrays: [
+        () => same([], []),
+        () => same([1, { a: 2 }], [1, { a: 2 }]),
+        // length first, then elementwise
+        () => differ([1], [1, 2]),
+        () => differ([1, 2], [2, 1]),
+        // an array is never the same as a non-array, in either position.
+        // `differ([], {})` alone does not pin this: it already fails on
+        // `0 === undefined`, so only an array-like with a matching `length`
+        // reaches the `b instanceof Array` check.
+        () => differ([], {}),
+        () => differ({}, []),
+        () => differ([1, 2], { 0: 1, 1: 2, length: 2 }),
+        // an explicitly `undefined` element is an ordinary element, so it
+        // counts towards the length
+        () => same([undefined], [undefined]),
+        () => differ([undefined], [1]),
+        () => differ([undefined], []),
+    ],
+    objects: [
+        () => same({}, {}),
+        // property order is not part of the structure
+        () => same({ a: 1, b: { c: 2 } }, { b: { c: 2 }, a: 1 }),
+        // same count, different names. The first is settled by the values
+        // (`1` vs `undefined`); only the second — disjoint names *and*
+        // `undefined` on both sides — pins the key-set check itself.
+        () => differ({ a: 1 }, { b: 1 }),
+        () => differ({ a: undefined }, { b: undefined }),
+        // same names, different values
+        () => differ({ a: 1 }, { a: 2 }),
+        () => differ({ a: { b: 1 } }, { a: { b: 2 } }),
+        // different counts
+        () => differ({ a: 1 }, { a: 1, b: 2 }),
+        // an `undefined`-valued property is still a property
+        () => differ({ a: undefined }, {}),
+        () => differ({}, { a: undefined }),
+    ],
+}

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

@@ -2,6 +2,11 @@
  * Ordered map operations with deterministic key traversal.
  *
  * @module
+ *
+ * @import { Sign } from '../function/compare/types.ts'
+ * @import { List } from '../list/types.ts'
+ * @import { Reduce } from '../function/operator/types.ts'
+ * @import { Entry, OrderedMap } from './types.ts'
  */
 import type { List } from '../list/types.ts';
 import type { Reduce } from '../function/operator/types.ts';

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

@@ -2,18 +2,19 @@
  * Ordered map operations with deterministic key traversal.
  *
  * @module
+ *
+ * @import { Sign } from '../function/compare/types.ts'
+ * @import { List } from '../list/types.ts'
+ * @import { Reduce } from '../function/operator/types.ts'
+ * @import { Entry, OrderedMap } from './types.ts'
  */
 
 import { value, find } from '../btree/find/module.f.mjs'
 import { set } from '../btree/set/module.f.mjs'
 import { remove as btreeRemove } from '../btree/remove/module.f.mjs'
 import { values } from '../btree/module.f.mjs'
-/** @import { Sign } from '../function/compare/types.ts' */
 import { cmp } from '../string/module.f.mjs'
-/** @import { List } from '../list/types.ts' */
 import { fold } from '../list/module.f.mjs'
-/** @import { Reduce } from '../function/operator/types.ts' */
-/** @import { Entry, OrderedMap } from './types.ts' */
 
 /** @type {(a: string) => <T>(b: Entry<T>) => Sign} */
 const keyCmp = a => ([b]) => cmp(a)(b)

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

@@ -1,3 +1,6 @@
+/**
+ * @import { OrderedMap } from './types.ts'
+ */
 export declare const proof: {
     main: (() => void)[];
     fromEntries: () => void;

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

@@ -1,5 +1,8 @@
+/**
+ * @import { OrderedMap } from './types.ts'
+ */
+
 import { at, setReplace, setReduce, empty, entries, remove, fromEntries } from './module.f.mjs'
-/** @import { OrderedMap } from './types.ts' */
 import { toArray } from '../list/module.f.mjs'
 import { assertEq } from '../../asserts/module.f.mjs'
 

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

@@ -2,9 +2,10 @@
  * Streaming Patricia trie for building content-addressed binary trees from sorted leaf sequences.
  *
  * @module
+ *
+ * @import { Candidate, Create, PatriciaTrie } from './types.ts'
  */
 import type { Create, PatriciaTrie } from './types.ts';
-/** @import { Candidate, Create, PatriciaTrie } from './types.ts' */
 /**
  * Creates a Patricia trie whose node merging is delegated to `create`.
  *

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

@@ -2,9 +2,11 @@
  * Streaming Patricia trie for building content-addressed binary trees from sorted leaf sequences.
  *
  * @module
+ *
+ * @import { Candidate, Create, PatriciaTrie } from './types.ts'
  */
 
-/** @import { Candidate, Create, PatriciaTrie } from './types.ts' */
+import { splitLast } from '../array/module.f.mjs'
 
 /**
  * Creates a Patricia trie whose node merging is delegated to `create`.
@@ -14,24 +16,37 @@
 export const patriciaTrie = create => ({
     push: (c, [storage, stack]) => {
         const [u] = c
-        while (stack.length >= 2) {
-            const [rLeaf, rHash] = stack[stack.length - 1]
-            const [lLeaf, lHash] = stack[stack.length - 2]
+        // Carry propagation: merge the top two candidates for as long as they
+        // are more tightly coupled to each other than the right one is to the
+        // incoming leaf. Genuinely sequential — each merge decides whether the
+        // next one happens — so the loop stays, but the stack is read by
+        // splitting rather than by index arithmetic. Either split answering
+        // `null` means fewer than two candidates are left, which is where the
+        // old `stack.length >= 2` guard stopped.
+        while (true) {
+            const top = splitLast(stack)
+            if (top === null) { break }
+            const [belowR, [rLeaf, rHash]] = top
+            const below = splitLast(belowR)
+            if (below === null) { break }
+            const [rest, [lLeaf, lHash]] = below
             if ((lLeaf ^ rLeaf) >= (rLeaf ^ u)) { break }
             const [h, newS] = create(lHash, rHash, storage)
             storage = newS
-            stack = [...stack.slice(0, -2), [rLeaf, h]]
+            stack = [...rest, [rLeaf, h]]
         }
         return [storage, [...stack, c]]
     },
+    // Drain the right spine into a root: a right fold whose seed is the last
+    // candidate's identity. `splitLast` supplies both halves at once, so the
+    // empty stack is the `null` branch rather than a separate length guard.
     end: ([storage, stack]) => {
-        if (stack.length === 0) { return [undefined, storage] }
-        let h = stack[stack.length - 1][1]
-        for (let i = stack.length - 2; i >= 0; i--) {
-            const lHash = stack[i][1];
-            [h, storage] = create(lHash, h, storage)
-        }
-        return [h, storage]
+        const split = splitLast(stack)
+        if (split === null) { return [undefined, storage] }
+        const [rest, [, lastHash]] = split
+        return rest.reduceRight(
+            ([h, s], [, lHash]) => create(lHash, h, s),
+            /** @type {readonly [typeof lastHash, typeof storage]} */([lastHash, storage]))
     }
 })
 

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

@@ -1,3 +1,6 @@
+/**
+ * @import { State } from './types.ts'
+ */
 export type _NodeList = readonly [bigint, bigint, bigint][];
 declare const empty: () => void;
 declare const singleLeaf: () => void;

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

@@ -1,6 +1,9 @@
+/**
+ * @import { State } from './types.ts'
+ */
+
 import { assert, assertEq } from '../../asserts/module.f.mjs'
 import { emptyState, patriciaTrie } from './module.f.mjs'
-/** @import { State } from './types.ts' */
 
 /** @typedef {readonly [bigint, bigint, bigint][]} _NodeList */
 

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

@@ -5,10 +5,12 @@
  * `p % 4 === 3`.
  *
  * @module
+ *
+ * @import { Reduce, Unary } from '../bigint/types.ts'
+ * @import { PrimeField } from './types.ts'
  */
 import type { Unary } from '../bigint/types.ts';
 import type { PrimeField } from './types.ts';
-/** @import { PrimeField } from './types.ts' */
 /**
  * Creates a prime field with the specified prime modulus and associated operations.
  *

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

@@ -5,12 +5,13 @@
  * `p % 4 === 3`.
  *
  * @module
+ *
+ * @import { Reduce, Unary } from '../bigint/types.ts'
+ * @import { PrimeField } from './types.ts'
  */
 
-/** @import { Reduce, Unary } from '../bigint/types.ts' */
 import { repeat } from '../../common/monoid/module.f.mjs'
 import { assertNotNullish } from '../../asserts/module.f.mjs'
-/** @import { PrimeField } from './types.ts' */
 
 /**
  * Creates a prime field with the specified prime modulus and associated operations.

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

@@ -2,9 +2,10 @@
  * Range and interval utilities for numeric boundaries.
  *
  * @module
+ *
+ * @import { Range } from './types.ts'
  */
 import type { Range } from './types.ts';
-/** @import { Range } from './types.ts' */
 /** @type {(...range: Range) => (i: number) => boolean} */
 export declare const contains: (...range: Range) => (i: number) => boolean;
 /** @type {(i: number) => Range} */

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

@@ -2,10 +2,10 @@
  * Range and interval utilities for numeric boundaries.
  *
  * @module
+ *
+ * @import { Range } from './types.ts'
  */
 
-/** @import { Range } from './types.ts' */
-
 /** @type {(...range: Range) => (i: number) => boolean} */
 export const contains = (b, e) => i => b <= i && i <= e
 

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

@@ -34,6 +34,12 @@
  * //
  * 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 type { Nullable } from '../nullable/types.ts';
 import type { Range } from '../range/types.ts';

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

@@ -34,21 +34,18 @@
  * //
  * 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 { TailReduce, ReduceOp } from '../sorted_list/types.ts' */
 import { next } from '../list/module.f.mjs'
-/** @import { Nullable } from '../nullable/types.ts' */
 import { cmp } from '../number/module.f.mjs'
 import { bsearch } from '../function/compare/module.f.mjs'
-/** @import { Equal } from '../function/operator/types.ts' */
-/** @import { Range } from '../range/types.ts' */
-/**
- * @import {
- *  Entry, Properties, RangeMapArray, RangeMapOp, RangeMerge,
- * } from './types.ts'
- */
 
 /** @template T @typedef {Nullable<Entry<T>>} _RangeState */
 

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

@@ -1,4 +1,8 @@
-/** @import { Unknown } from '../../media/json/types.ts' */
+/**
+ * @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)[];

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

@@ -1,11 +1,13 @@
-/** @import { Unknown } from '../../media/json/types.ts' */
+/**
+ * @import { Unknown } from '../../media/json/types.ts'
+ * @import { RangeMapArray, Properties, RangeMap } from './types.ts'
+ * @import { SortedSet } from '../sorted_set/types.ts'
+ */
 
-/** @import { RangeMapArray, Properties, RangeMap } from './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 { SortedSet } from '../sorted_set/types.ts' */
 import { equal, toArray } from '../list/module.f.mjs'
 import { strictEqual } from '../function/operator/module.f.mjs'
 import { cmp } from '../string/module.f.mjs'

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

@@ -1,3 +1,8 @@
+/**
+ * A set of numeric ranges, represented as a `range_map` of `boolean`.
+ *
+ * @module
+ */
 /**
  * Constructs a range set containing a single numeric range.
  */

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

@@ -3,6 +3,7 @@
  *
  * @module
  */
+
 import { rangeMap } from '../range_map/module.f.mjs'
 
 const map = rangeMap({

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

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

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

@@ -1,7 +1,10 @@
+/**
+ * @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'
-/** @import { Range } from '../range/types.ts' */
 
 /** @type {(a: string) => number} */
 const c = a => a.charCodeAt(0)

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

@@ -1,3 +1,11 @@
+/**
+ * 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>;