functionalscript 0.44.0 → 0.46.0

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

@@ -20,34 +20,23 @@
  * ```
  *
  * @module
+ *
+ * @import { Reduce as BigintReduce } from '../bigint/types.ts'
+ * @import { Fold } from '../function/operator/types.ts'
+ * @import { List, Thunk } from '../list/types.ts'
+ * @import { Absorbing } from '../../common/monoid/types.ts'
+ * @import { Sign } from '../function/compare/types.ts'
+ * @import { Nullable } from '../nullable/types.ts'
+ * @import { BitOrder, PopFront, Reduce, Unpacked, Vec, _NormOp, _UnpackConcat, } from './types.ts'
  */
 
 import { bitLength, divUp, mask, maxLength, xor } from '../bigint/module.f.mjs'
-/** @import { Reduce as BigintReduce } from '../bigint/types.ts' */
-
-import { flip, identity } from '../function/module.f.mjs'
-
-/** @import { Fold } from '../function/operator/types.ts' */
-
-import { map, tryFold } from '../list/module.f.mjs'
-/** @import { Accumulator, List, Thunk } from '../list/types.ts' */
-
+import { compose, flip, identity } from '../function/module.f.mjs'
+import { map } from '../list/module.f.mjs'
 import { asBase, asNominal } from '../nominal/module.f.mjs'
-
-import { repeat as mRepeat } from '../../common/monoid/module.f.mjs'
-
+import { foldAbsorbing, repeat as mRepeat } from '../../common/monoid/module.f.mjs'
 import { cmp, max, min } from '../function/compare/module.f.mjs'
-/** @import { Sign } from '../function/compare/types.ts' */
-
-import { mapUnwrap } from '../nullable/module.f.mjs'
-/** @import { Nullable } from '../nullable/types.ts' */
-
-/**
- * @import {
- *  BitOrder, PopFront, Reduce, Unpacked, Vec,
- *  _NormOp, _UnpackConcat,
- * } from './types.ts'
- */
+import { map as nullableMap, mapUnwrap } from '../nullable/module.f.mjs'
 
 /**
  * Maximum length of a bit vector in bits (1_048_576 = 0x10_0000).
@@ -183,8 +172,6 @@ const op = norm => op => ap => bp => {
 
 /**
  * @typedef {{
- *  readonly front: (len: bigint) => (v: Vec) => bigint
- *  readonly removeFront: (len: bigint) => (v: Vec) => Vec
  *  readonly norm: _NormOp
  *  readonly uintCmp: (a: bigint) => (b: bigint) => Sign
  *  readonly unpackSplit: (len: bigint) => (u: Unpacked) => readonly[bigint, bigint]
@@ -195,55 +182,62 @@ const op = norm => op => ap => bp => {
 const unpackEmpty = /** @type {const} */{ length: 0n, uint: 0n }
 
 /**
- * @typedef {{
- *  readonly len: bigint
- *  readonly stack: readonly Unpacked[]
- * }} _ListToVecState
+ * The element-to-`Unpacked` maps the two {@link mappedListToVec} instances
+ * differ by. Neither depends on a bit order, so both are bound once here
+ * (`fjs/AGENTS.md` §3.3).
+ *
+ * @type {(_: number) => Unpacked}
  */
+const u8ToUnpacked = b => ({ length: 8n, uint: BigInt(b) })
 
-/** @typedef {Accumulator<Unpacked, _ListToVecState, Vec>} _ListToVecOp */
-
-/** @type {(unpackConcat: _UnpackConcat) => _ListToVecOp} */
-const listToVecOp = unpackConcat => ({
-    init: { len: 0n, stack: [] },
-    update: (v, {len, stack}) => {
-        len += v.length
-        if (len > maxLength) { return null }
-        let i = 0
-        while (true) {
-            if (stack.length <= i) {
-                stack = [...stack, v]
-                break
-            }
-            const old = stack[i]
-            if (old.length === 0n) {
-                stack = stack.toSpliced(i, 1, v)
-                break
-            }
-            stack = stack.toSpliced(i, 1, unpackEmpty)
-            v = unpackConcat(old)(v)
-            i++
-        }
-        return { len, stack }
+/**
+ * Concatenation as a monoid over `Nullable<Unpacked>`, where `null` means "the
+ * concatenation is longer than `maxLength`" and is an **absorbing** element:
+ * combining it with anything is `null` again. The identity is the empty vector.
+ *
+ * This is a lawful monoid, so `monoid.fold` may re-associate it freely. Length
+ * is additive and non-negative, so any partial combine is at most the total: a
+ * partial can only overflow when the total does, and the top-level combine
+ * always sees the full total. The result is therefore `null` **iff** the total
+ * length exceeds `maxLength`, whatever the grouping.
+ *
+ * The cap is checked on the operands' lengths rather than on the concatenated
+ * result because the result is what must not be built: `maxLength` is the
+ * smallest `bigint` size supported across FunctionalScript's runtimes. The two
+ * lengths are exact and additive — this is the length, not an estimate of it
+ * (`DESIGN.md` §6).
+ *
+ * Being absorbing is also what keeps the fold's walk bounded: `foldAbsorbing`
+ * stops at the first merge that overflows instead of reading the rest of a list
+ * whose answer is already `null`. `List<T>` includes `Thunk<T>`, so that is the
+ * difference between answering and never returning on an unbounded lazy list —
+ * and at `maxLength` = 128 KiB, overflow is an ordinary outcome for a stream,
+ * not an exotic one. Since a single vector is never `null`, only a merge can
+ * reach the absorbing element, so the stop lags the element that crossed the cap
+ * by at most one doubling of the run size (measured: 65 536 elements read for a
+ * cap crossed at 32 769, and 4 for a cap crossed at 3).
+ *
+ * @type {(unpackConcat: _UnpackConcat) => Absorbing<Nullable<Unpacked>>}
+ */
+const tryUnpackConcat = unpackConcat => ({
+    monoid: {
+        identity: unpackEmpty,
+        operation: a => b =>
+            a === null || b === null || a.length + b.length > maxLength
+                ? null
+                : unpackConcat(a)(b)
     },
-    end: ({stack}) => pack(stack.reduce((p, c) => unpackConcat(c)(p), unpackEmpty))
+    absorbing: null,
 })
 
 /**
- * Concatenates a list of unpacked vectors using a binary-counter accumulator,
- * giving O(n log n) total `bigint` shifting work instead of the O(n²) of a
- * naive left fold.
- *
- * Slot `i` of `result` holds an already-combined run of the most recent
- * `2 ** i` elements. Each arriving element "carries" upward, merging only with
- * runs of comparable size — exactly like incrementing a binary number — so
- * every merge joins two runs of similar length. Left-to-right element order is
- * preserved: `unpackConcat(old)(cur)` keeps the earlier run on the left, and
- * the final reduce prepends higher (earlier) slots in front of accumulated
- * later runs. An empty list yields `unpackEmpty`.
+ * Concatenates a list of unpacked vectors, or `null` if the result would be
+ * longer than `maxLength`.
  *
- * Returns `null` as soon as the accumulated length exceeds `maxLength`, which
- * `tryFold` propagates by abandoning the rest of the list.
+ * `monoid.foldAbsorbing` reduces as a balanced binary tree, so each merge joins
+ * two runs of comparable size — O(n log n) total `bigint` shifting work instead
+ * of the O(n²) a left fold would spend growing one accumulator against small
+ * operands — and stops reading at the first overflow.
  *
  * This is the bit-vector analogue of a builder that accumulates appended pieces
  * and materializes the combined result on demand, such as `StringBuilder`
@@ -251,10 +245,29 @@ const listToVecOp = unpackConcat => ({
  *
  * @param {_UnpackConcat} unpackConcat
  */
-const unpackListToVec = unpackConcat => tryFold(listToVecOp(unpackConcat))
+const unpackListToVec = unpackConcat =>
+    compose(foldAbsorbing(tryUnpackConcat(unpackConcat)))(nullableMap(pack))
+
+/**
+ * Concatenates a list of `I` values into one vector, mapping each element to
+ * its `Unpacked` form first; `null` when the result would exceed `maxLength`.
+ *
+ * The concatenation counterpart of {@link mappedChunkList}. Everything about
+ * the operation is fixed except how one element becomes `Unpacked`, so each
+ * element type supplies just that map. The `bo` parameter is structural rather
+ * than a whole `BitOrder` because `bo`'s own body applies this before the
+ * record exists.
+ *
+ * @type {<I>(g: (i: I) => Unpacked) => (bo: { readonly unpackConcat: _UnpackConcat }) => (list: List<I>) => Nullable<Vec>}
+ */
+const mappedListToVec = g => ({ unpackConcat }) => {
+    const f = unpackListToVec(unpackConcat)
+    const mg = map(g)
+    return list => f(mg(list))
+}
 
 /** @type {(base: _Base) => BitOrder} */
-const bo = ({ front, removeFront, norm, uintCmp, unpackSplit, unpackConcatUint }) => {
+const bo = ({ norm, uintCmp, unpackSplit, unpackConcatUint }) => {
     /** @param {bigint} len */
     const unpackPopFront = len => {
         const m = mask(len)
@@ -265,6 +278,19 @@ const bo = ({ front, removeFront, norm, uintCmp, unpackSplit, unpackConcatUint }
             return /** @type {const} */([uint & m, { length: v.length - len, uint: rest }])
         }
     }
+    // `front` and `removeFront` are the two projections of `unpackPopFront`,
+    // so each bit order supplies only `unpackSplit` and both fall out of it.
+    // `pack` re-masks, so `removeFront` can hand on the unmasked rest.
+    /** @type {(len: bigint) => (v: Vec) => bigint} */
+    const front = len => {
+        const f = unpackPopFront(len)
+        return v => f(unpack(v))[0]
+    }
+    /** @type {(len: bigint) => (v: Vec) => Vec} */
+    const removeFront = len => {
+        const f = unpackPopFront(len)
+        return v => pack(f(unpack(v))[1])
+    }
     /** @type {_UnpackConcat} */
     const unpackConcat = a => b => ({
         length: a.length + b.length,
@@ -284,9 +310,7 @@ const bo = ({ front, removeFront, norm, uintCmp, unpackSplit, unpackConcatUint }
         const bu = unpack(b)
         return pack(unpackConcat(au)(bu))
     }
-    /** @param {List<Vec>} list */
-    const tryListToVec = list =>
-        unpackListToVec(unpackConcat)(map(unpack)(list))
+    const tryListToVec = mappedListToVec(unpack)({ unpackConcat })
     return {
         front,
         removeFront,
@@ -310,7 +334,8 @@ const bo = ({ front, removeFront, norm, uintCmp, unpackSplit, unpackConcatUint }
         unpackConcat,
         startsWith: prefix => {
             const { length: n, uint: u } = unpack(prefix)
-            return v => length(v) < n ? false : popFront(n)(v)[0] === u
+            const f = front(n)
+            return v => length(v) < n ? false : f(v) === u
         }
     }
 }
@@ -327,14 +352,6 @@ const lsbUnpackConcatUint =
  * Usually associated with Little-Endian (LE) byte order.
  */
 export const lsb = bo({
-    front: len => {
-        const m = mask(len)
-        return v => uint(v) & m
-    },
-    removeFront: len => v => {
-        const { length, uint } = unpack(v)
-        return vec(length - len)(uint >> len)
-    },
     norm: ({ uint: a }) => ({ uint: b }) => () =>
         ({ a, b }),
     uintCmp: a => b => {
@@ -353,17 +370,6 @@ export const lsb = bo({
  * Usually associated with Big-Endian (BE) byte order.
  */
 export const msb = bo({
-    front: len => {
-        const m = mask(len)
-        return v => {
-            const { length, uint } = unpack(v)
-            return (uint >> (length - len)) & m
-        }
-    },
-    removeFront: len => v => {
-        const { length, uint } = unpack(v)
-        return vec(length - len)(uint)
-    },
     norm: ({ length: al, uint: a }) => ({ length: bl, uint: b }) => len =>
         ({ a: a << (len - al), b: b << (len - bl) }),
     uintCmp: cmp,
@@ -378,9 +384,7 @@ export const msb = bo({
  *
  * @type {(_: BitOrder) => (list: List<number>) => Nullable<Vec>}
  */
-export const tryU8ListToVec = ({ unpackConcat }) => list =>
-    unpackListToVec(unpackConcat)(
-        map(/** @type {(_: number) => Unpacked} */b => ({ length: 8n, uint: BigInt(b) }))(list))
+export const tryU8ListToVec = mappedListToVec(u8ToUnpacked)
 
 /**
  * Converts a list of unsigned 8-bit integers to a bit vector using the provided bit order.

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

@@ -1,3 +1,8 @@
+/**
+ * @import { Sign } from '../function/compare/types.ts'
+ * @import { Vec, BitOrder } from './types.ts'
+ * @import { List } from '../list/types.ts'
+ */
 export declare const proof: {
     fromSentinel: () => void;
     examples: {
@@ -47,6 +52,7 @@ export declare const proof: {
     };
     u8ListToVec: () => () => void;
     tryListToVecOverflow: () => void;
+    tryListToVecUnbounded: () => void;
     listToVecOverflow: {
         throw: () => void;
     };

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

@@ -1,10 +1,13 @@
+/**
+ * @import { Sign } from '../function/compare/types.ts'
+ * @import { Vec, BitOrder } from './types.ts'
+ * @import { List } from '../list/types.ts'
+ */
+
 import { assert, assertEq } from '../../asserts/module.f.mjs'
 import { mask } from '../bigint/module.f.mjs'
-/** @import { Sign } from '../function/compare/types.ts' */
 import { asBase, asNominal } from '../nominal/module.f.mjs'
-/** @import { Vec, BitOrder } from './types.ts' */
 import { length, empty, uint, vec, lsb, msb, repeat, vec8, maxLength, u8ListToVec, tryU8ListToVec, u8List, chunkList, fromSentinel } from './module.f.mjs'
-/** @import { List } from '../list/types.ts' */
 import { repeat as listRepeat, toArray } from '../list/module.f.mjs'
 
 /** @type {(a: bigint) => Vec} */
@@ -190,9 +193,9 @@ export const proof = {
     },
     removeBack: () => {
         const v = vec(17n)(0x12345n)
-        assertEq(v, unsafeVec(0x12345n), (/** @type {bigint} */ (asBase(v))).toString(16))
+        assertEq(v, unsafeVec(0x12345n), (asBase(v)).toString(16))
         const r = lsb.removeFront(9n)(v)
-        assertEq(r, unsafeVec(0x91n), (/** @type {bigint} */ (asBase(r))).toString(16))
+        assertEq(r, unsafeVec(0x91n), (asBase(r)).toString(16))
     },
     uint: [
         // 0
@@ -421,6 +424,29 @@ export const proof = {
         const list = [vec(maxLength)(1n), vec(1n)(1n)]
         assertEq(lsb.tryListToVec(list), null)
         assertEq(msb.tryListToVec(list), null)
+        // Overflow is an absorbing element, so it survives every later
+        // combination: here the failed pair ends up on the left of the last
+        // one, and on the right in the two-element case above.
+        /** @type {List<Vec>} */
+        const longer = [vec(maxLength)(1n), vec(1n)(1n), vec(1n)(1n)]
+        assertEq(lsb.tryListToVec(longer), null)
+        assertEq(msb.tryListToVec(longer), null)
+    },
+    tryListToVecUnbounded: () => {
+        // `List` includes `Thunk`, so an unbounded lazy list is a legal input —
+        // and at 128 KiB, `maxLength` is an ordinary amount for a stream to
+        // exceed. Overflow being absorbing is what lets the fold answer instead
+        // of reading forever: each element here is half of `maxLength`, so the
+        // total crosses the cap at the third and the merge that sees it happens
+        // at the fourth. The rest of the list asserts it is never read.
+        const half = vec(maxLength / 2n)(1n)
+        /** @type {(n: number) => List<Vec>} */
+        const from = n => () => {
+            assert(n <= 8)
+            return { first: half, tail: from(n + 1) }
+        }
+        assertEq(lsb.tryListToVec(from(1)), null)
+        assertEq(msb.tryListToVec(from(1)), null)
     },
     listToVecOverflow: {
         // Same oversized input, but through the throwing `listToVec` wrapper.

package/fjs/types/btree/find/module.f.d.mts

@@ -2,8 +2,12 @@
  * Lookup operations for persistent B-tree structures.
  *
  * @module
+ *
+ * @import { TNode } from '../types/types.ts'
+ * @import { Compare } from '../../function/compare/types.ts'
+ * @import { KeyOf } from '../../array/types.ts'
+ * @import { First, Path, PathItem, Result } from './types.ts'
  */
-/** @import { TNode } from '../types/types.ts' */
 import type { TNode } from '../types/types.ts';
 import type { Compare } from '../../function/compare/types.ts';
 import type { First, Result } from './types.ts';

package/fjs/types/btree/find/module.f.mjs

@@ -2,14 +2,14 @@
  * Lookup operations for persistent B-tree structures.
  *
  * @module
+ *
+ * @import { TNode } from '../types/types.ts'
+ * @import { Compare } from '../../function/compare/types.ts'
+ * @import { KeyOf } from '../../array/types.ts'
+ * @import { First, Path, PathItem, Result } from './types.ts'
  */
-/** @import { TNode } from '../types/types.ts' */
 
 import { index3, index5 } from '../../function/compare/module.f.mjs'
-/** @import { Compare } from '../../function/compare/types.ts' */
-
-/** @import { KeyOf } from '../../array/types.ts' */
-/** @import { First, Path, PathItem, Result } from './types.ts' */
 
 /** @type {<T>(item: PathItem<T>) => TNode<T>} */
 const child = item => {

package/fjs/types/btree/find/proof.f.d.mts

@@ -1,4 +1,8 @@
-/** @import { Unknown } from '../../../media/json/types.ts' */
+/**
+ * @import { Unknown } from '../../../media/json/types.ts'
+ * @import { Result } from './types.ts'
+ * @import { TNode } from '../types/types.ts'
+ */
 declare const test: () => void;
 export declare const proof: typeof test;
 export {};

package/fjs/types/btree/find/proof.f.mjs

@@ -1,11 +1,13 @@
-/** @import { Unknown } from '../../../media/json/types.ts' */
+/**
+ * @import { Unknown } from '../../../media/json/types.ts'
+ * @import { Result } from './types.ts'
+ * @import { TNode } from '../types/types.ts'
+ */
 
-/** @import { Result } from './types.ts' */
 import { find as btreeFind } from './module.f.mjs'
 import { map, toArray } from '../../list/module.f.mjs'
 import { stringify } from '../../../media/json/module.f.mjs'
 import { sort } from '../../object/module.f.mjs'
-/** @import { TNode } from '../types/types.ts' */
 import { cmp } from '../../string/module.f.mjs'
 import { set as setSet } from '../set/module.f.mjs'
 import { assertEq } from '../../../asserts/module.f.mjs'

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

@@ -2,6 +2,9 @@
  * Core persistent B-tree construction and traversal helpers.
  *
  * @module
+ *
+ * @import { List, Thunk } from '../list/types.ts'
+ * @import { TNode, Tree } from './types/types.ts'
  */
 import type { List } from '../list/types.ts';
 import type { Tree } from './types/types.ts';

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

@@ -2,12 +2,13 @@
  * Core persistent B-tree construction and traversal helpers.
  *
  * @module
+ *
+ * @import { List, Thunk } from '../list/types.ts'
+ * @import { TNode, Tree } from './types/types.ts'
  */
 
 import { flat } from '../list/module.f.mjs'
-/** @import { List, Thunk } from '../list/types.ts' */
 import { map } from '../nullable/module.f.mjs'
-/** @import { TNode, Tree } from './types/types.ts' */
 
 /** @type {<T>(node: TNode<T>) => Thunk<T>} */
 const nodeValues

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

@@ -1,4 +1,8 @@
-/** @import { Unknown } from '../../media/json/types.ts' */
+/**
+ * @import { Unknown } from '../../media/json/types.ts'
+ * @import { TNode } from './types/types.ts'
+ * @import { List, Result } from '../list/types.ts'
+ */
 declare const valueTest1: () => void;
 declare const valuesTest2: () => void;
 declare const findTrue: () => void;

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

@@ -1,11 +1,13 @@
-/** @import { Unknown } from '../../media/json/types.ts' */
+/**
+ * @import { Unknown } from '../../media/json/types.ts'
+ * @import { TNode } from './types/types.ts'
+ * @import { List, Result } from '../list/types.ts'
+ */
 
-/** @import { TNode } from './types/types.ts' */
 import { values } from './module.f.mjs'
 import { stringify as jsonStringify } from '../../media/json/module.f.mjs'
 import { sort } from '../object/module.f.mjs'
 import { cmp } from '../string/module.f.mjs'
-/** @import { List, Result } from '../list/types.ts' */
 import { next, toArray } from '../list/module.f.mjs'
 import { set as setSet } from './set/module.f.mjs'
 import { value, find as findFind } from './find/module.f.mjs'

package/fjs/types/btree/remove/module.f.d.mts

@@ -1,3 +1,13 @@
+/**
+ * Removal operations for persistent B-tree structures.
+ *
+ * @module
+ *
+ * @import { Leaf1, TNode, Branch1, Branch3, Branch5, Tree } from '../types/types.ts'
+ * @import { Compare } from '../../function/compare/types.ts'
+ * @import { Path, PathItem } from '../find/types.ts'
+ * @import { Tuple } from '../../array/types.ts'
+ */
 import type { Leaf1, TNode, Branch1, Branch3, Branch5, Tree } from '../types/types.ts';
 import type { Compare } from '../../function/compare/types.ts';
 import type { Path } from '../find/types.ts';
@@ -16,6 +26,7 @@ export declare const proof: {
     throw: {
         reduceValue0DefaultBranch: () => void;
         reduceValue2DefaultBranch: () => void;
+        initValue0DefaultBranch: () => void;
         initValue1DefaultBranch: () => void;
     };
 };

package/fjs/types/btree/remove/module.f.mjs

@@ -2,19 +2,16 @@
  * Removal operations for persistent B-tree structures.
  *
  * @module
+ *
+ * @import { Leaf1, TNode, Branch1, Branch3, Branch5, Tree } from '../types/types.ts'
+ * @import { Compare } from '../../function/compare/types.ts'
+ * @import { Path, PathItem } from '../find/types.ts'
+ * @import { Tuple } from '../../array/types.ts'
  */
-import { collapseRoot } from '../types/module.f.mjs'
-/** @import { Leaf1, TNode, Branch1, Branch3, Branch5, Tree } from '../types/types.ts' */
-
-/** @import { Compare } from '../../function/compare/types.ts' */
 
+import { collapseRoot } from '../types/module.f.mjs'
 import { find } from '../find/module.f.mjs'
-/** @import { Path, PathItem } from '../find/types.ts' */
-
 import { fold, concat, next } from '../../list/module.f.mjs'
-
-/** @import { Tuple } from '../../array/types.ts' */
-
 import { map } from '../../nullable/module.f.mjs'
 
 /**
@@ -133,7 +130,7 @@ export const nodeRemove = c => node => {
         const { first, tail } = find(c)(node)
         /** @type {(n: TNode<T>) => (f: (v: T) => PathItem<T>) => _RemovePath<T>} */
         const branch = n => f => {
-            const [v, p] = path(/** @type {Path<T>} */(null))(n)
+            const [v, p] = path(null)(n)
             return { first: p.first, tail: concat(p.tail)({ first: f(v), tail }) }
         }
         const [i, n] = first
@@ -180,6 +177,9 @@ export const proof = {
         reduceValue2DefaultBranch: () => {
             reduceValue2([['leaf']])([['x'], 's', ['y']])
         },
+        initValue0DefaultBranch: () => {
+            initValue0(null)([['x'], 's', [['a'], 'b', ['c']]])
+        },
         initValue1DefaultBranch: () => {
             initValue1(null)([[['a'], 'b', ['c']], 'd', ['e']])
         },

package/fjs/types/btree/remove/proof.f.d.mts

@@ -1,3 +1,6 @@
+/**
+ * @import { TNode } from '../types/types.ts'
+ */
 declare const test: () => void;
 declare const test2: () => void;
 declare const test3: () => void;

package/fjs/types/btree/remove/proof.f.mjs

@@ -1,5 +1,8 @@
+/**
+ * @import { TNode } from '../types/types.ts'
+ */
+
 import { nodeRemove } from './module.f.mjs'
-/** @import { TNode } from '../types/types.ts' */
 import { set as setSet } from '../set/module.f.mjs'
 import { cmp } from '../../string/module.f.mjs'
 import { stringify } from '../../../media/json/module.f.mjs'

package/fjs/types/btree/set/module.f.d.mts

@@ -1,3 +1,12 @@
+/**
+ * Insertion and update operations for persistent B-tree structures.
+ *
+ * @module
+ *
+ * @import { Branch1, Branch3, Branch5, Branch7, TNode, Tree } from '../types/types.ts'
+ * @import { First, PathItem, Result } from '../find/types.ts'
+ * @import { Compare } from '../../function/compare/types.ts'
+ */
 import type { Branch1, Branch3, TNode, Tree } from '../types/types.ts';
 import type { Compare } from '../../function/compare/types.ts';
 export type _Branch1To3<T> = Branch1<T> | Branch3<T>;

package/fjs/types/btree/set/module.f.mjs

@@ -2,16 +2,16 @@
  * Insertion and update operations for persistent B-tree structures.
  *
  * @module
+ *
+ * @import { Branch1, Branch3, Branch5, Branch7, TNode, Tree } from '../types/types.ts'
+ * @import { First, PathItem, Result } from '../find/types.ts'
+ * @import { Compare } from '../../function/compare/types.ts'
  */
-import { collapseRoot } from '../types/module.f.mjs'
-/** @import { Branch1, Branch3, Branch5, Branch7, TNode, Tree } from '../types/types.ts' */
 
+import { collapseRoot } from '../types/module.f.mjs'
 import { find } from '../find/module.f.mjs'
-/** @import { First, PathItem, Result } from '../find/types.ts' */
-
-/** @import { Compare } from '../../function/compare/types.ts' */
-
 import { fold } from '../../list/module.f.mjs'
+import { assert } from '../../../asserts/module.f.mjs'
 
 /**
  * @template T
@@ -81,30 +81,27 @@ const nodeSet = c => g => node => {
                 // insert
                 const value = g(null)
                 // TODO: remove after TSGO fix the regression.
-                // const _xl: 1|2 = x.length
-                switch (x.length) {
+                const xL = x.length
+                // See https://github.com/microsoft/typescript-go/issues/4613
+                assert(xL === 1 || xL === 2)
+                switch (xL) {
                     case 1: { return [[x[0], value]] }
                     case 2: { return [[x[0]], value, [x[1]]] }
                 }
-                // TODO: remove after TSGO fix the regression.
-                // See https://github.com/microsoft/typescript-go/issues/4613
-                throw 'unreachable'
             }
             case 3: {
                 // replace
                 // TODO: remove after TSGO fix the regression.
-                // const _xl: 2|5 = x.length
-                switch (x.length) {
+                const xL = x.length
+                // See https://github.com/microsoft/typescript-go/issues/4613
+                assert(xL === 2 || xL === 5)
+                switch (xL) {
                     case 2: { return [[x[0], g(x[1])]] }
                     case 5: { return [[x[0], x[1], x[2], g(x[3]), x[4]]] }
                 }
-                // TODO: remove after TSGO fix the regression.
-                throw 'unreachable'
             }
             case 4: {
                 // insert
-                // TODO: remove after TSGO fix the regression.
-                // const _xl: 2 = x.length
                 const [v0, v1] = x
                 return [[v0], v1, [g(null)]]
             }

package/fjs/types/btree/set/proof.f.d.mts

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