functionalscript 0.43.1 → 0.45.0

package/fjs/types/btree/set/proof.f.js

@@ -1,368 +0,0 @@
-import { set as setSet } from './module.f.js';
-import { cmp } from '../../string/module.f.js';
-import { stringify } from '../../../media/json/module.f.js';
-import { sort } from '../../object/module.f.js';
-import { assertEq } from '../../../asserts/module.f.js';
-const set = (node) => (value) => setSet(cmp(value))(() => value)(node);
-const replace = (node) => (value) => (g) => setSet(cmp(value))(g)(node);
-const jsonStr = stringify(sort);
-const test = [
-    () => {
-        let _map = ['1'];
-        for (let i = 2; i <= 10; i++)
-            _map = set(_map)((i * i).toString());
-        const r = jsonStr(_map);
-        assertEq(r, '[[["1","100"],"16",["25","36"]],"4",[["49"],"64",["81","9"]]]');
-    },
-    () => {
-        let _map = ['1'];
-        for (let i = 2; i <= 11; i++)
-            _map = set(_map)((i * i).toString());
-        const r = jsonStr(_map);
-        assertEq(r, '[[["1"],"100",["121"],"16",["25","36"]],"4",[["49"],"64",["81","9"]]]');
-    },
-    () => {
-        let _map = ['1'];
-        for (let i = 2; i <= 12; i++)
-            _map = set(_map)((i * i).toString());
-        const r = jsonStr(_map);
-        assertEq(r, '[[["1"],"100",["121","144"],"16",["25","36"]],"4",[["49"],"64",["81","9"]]]');
-    },
-    () => {
-        let _map = ['1'];
-        for (let i = 2; i <= 13; i++)
-            _map = set(_map)((i * i).toString());
-        const r = jsonStr(_map);
-        assertEq(r, '[[["1"],"100",["121","144"]],"16",[["169"],"25",["36"]],"4",[["49"],"64",["81","9"]]]');
-    },
-    () => {
-        let _map = ['1'];
-        for (let i = 2; i <= 14; i++)
-            _map = set(_map)((i * i).toString());
-        const r = jsonStr(_map);
-        assertEq(r, '[[["1"],"100",["121","144"]],"16",[["169","196"],"25",["36"]],"4",[["49"],"64",["81","9"]]]');
-    },
-    () => {
-        let _map = ['1'];
-        for (let i = 2; i <= 15; i++)
-            _map = set(_map)((i * i).toString());
-        const r = jsonStr(_map);
-        assertEq(r, '[[["1"],"100",["121","144"]],"16",[["169"],"196",["225"],"25",["36"]],"4",[["49"],"64",["81","9"]]]');
-    },
-    () => {
-        let _map = ['1'];
-        for (let i = 2; i <= 16; i++)
-            _map = set(_map)((i * i).toString());
-        const r = jsonStr(_map);
-        assertEq(r, '[[["1"],"100",["121","144"]],"16",[["169"],"196",["225"],"25",["256","36"]],"4",[["49"],"64",["81","9"]]]');
-    },
-    () => {
-        let _map = ['1'];
-        for (let i = 2; i <= 17; i++)
-            _map = set(_map)((i * i).toString());
-        const r = jsonStr(_map);
-        assertEq(r, '[[[["1"],"100",["121","144"]],"16",[["169"],"196",["225"]]],"25",[[["256"],"289",["36"]],"4",[["49"],"64",["81","9"]]]]');
-    },
-    () => {
-        let _map = ['1'];
-        for (let i = 2; i <= 18; i++)
-            _map = set(_map)((i * i).toString());
-        const r = jsonStr(_map);
-        if (r !==
-            '[[[["1"],"100",["121","144"]],"16",[["169"],"196",["225"]]],"25",[[["256"],"289",["324","36"]],"4",[["49"],"64",["81","9"]]]]') {
-            throw r;
-        }
-    },
-    () => {
-        let _map = ['1'];
-        for (let i = 2; i <= 19; i++)
-            _map = set(_map)((i * i).toString());
-        const r = jsonStr(_map);
-        if (r !==
-            '[[[["1"],"100",["121","144"]],"16",[["169"],"196",["225"]]],"25",[[["256"],"289",["324"],"36",["361"]],"4",[["49"],"64",["81","9"]]]]') {
-            throw r;
-        }
-    },
-    () => {
-        let _map = ['1'];
-        for (let i = 2; i <= 20; i++)
-            _map = set(_map)((i * i).toString());
-        const r = jsonStr(_map);
-        if (r !==
-            '[[[["1"],"100",["121","144"]],"16",[["169"],"196",["225"]]],' +
-                '"25",' +
-                '[[["256"],"289",["324"],"36",["361"]],"4",[["400","49"],"64",["81","9"]]]]') {
-            throw r;
-        }
-    },
-    () => {
-        let _map = ['1'];
-        for (let i = 2; i <= 21; i++)
-            _map = set(_map)((i * i).toString());
-        const r = jsonStr(_map);
-        if (r !==
-            '[[[["1"],"100",["121","144"]],"16",[["169"],"196",["225"]]],' +
-                '"25",' +
-                '[[["256"],"289",["324"],"36",["361"]],"4",[["400"],"441",["49"],"64",["81","9"]]]]') {
-            throw r;
-        }
-    },
-    () => {
-        let _map = ['1'];
-        for (let i = 2; i <= 22; i++)
-            _map = set(_map)((i * i).toString());
-        const r = jsonStr(_map);
-        if (r !==
-            '[[[["1"],"100",["121","144"]],"16",[["169"],"196",["225"]]],' +
-                '"25",' +
-                '[[["256"],"289",["324"],"36",["361"]],"4",[["400"],"441",["484","49"],"64",["81","9"]]]]') {
-            throw r;
-        }
-    },
-    () => {
-        let _map = ['1'];
-        for (let i = 2; i <= 23; i++)
-            _map = set(_map)((i * i).toString());
-        const r = jsonStr(_map);
-        if (r !==
-            '[[[["1"],"100",["121","144"]],"16",[["169"],"196",["225"]]],' +
-                '"25",' +
-                '[[["256"],"289",["324"],"36",["361"]],"4",[["400"],"441",["484"]],"49",[["529"],"64",["81","9"]]]]') {
-            throw r;
-        }
-    },
-    () => {
-        let _map = ['1'];
-        for (let i = 2; i <= 24; i++)
-            _map = set(_map)((i * i).toString());
-        const r = jsonStr(_map);
-        if (r !==
-            '[[[["1"],"100",["121","144"]],"16",[["169"],"196",["225"]]],' +
-                '"25",' +
-                '[[["256"],"289",["324"],"36",["361"]],"4",[["400"],"441",["484"]],"49",[["529","576"],"64",["81","9"]]]]') {
-            throw r;
-        }
-    },
-    () => {
-        let _map = ['1'];
-        for (let i = 2; i <= 25; i++)
-            _map = set(_map)((i * i).toString());
-        const r = jsonStr(_map);
-        if (r !==
-            '[[[["1"],"100",["121","144"]],"16",[["169"],"196",["225"]]],' +
-                '"25",' +
-                '[[["256"],"289",["324"],"36",["361"]],"4",[["400"],"441",["484"]],"49",[["529"],"576",["625"],"64",["81","9"]]]]') {
-            throw r;
-        }
-    },
-    () => {
-        let _map = ['1'];
-        for (let i = 2; i <= 26; i++)
-            _map = set(_map)((i * i).toString());
-        const r = jsonStr(_map);
-        if (r !==
-            '[[[["1"],"100",["121","144"]],"16",[["169"],"196",["225"]]],' +
-                '"25",' +
-                '[[["256"],"289",["324"],"36",["361"]],"4",[["400"],"441",["484"]]],' +
-                '"49",' +
-                '[[["529"],"576",["625"]],"64",[["676"],"81",["9"]]]]') {
-            throw r;
-        }
-    },
-    () => {
-        let _map = ['1'];
-        for (let i = 2; i <= 27; i++)
-            _map = set(_map)((i * i).toString());
-        const r = jsonStr(_map);
-        if (r !==
-            '[[[["1"],"100",["121","144"]],"16",[["169"],"196",["225"]]],' +
-                '"25",' +
-                '[[["256"],"289",["324"],"36",["361"]],"4",[["400"],"441",["484"]]],' +
-                '"49",' +
-                '[[["529"],"576",["625"]],"64",[["676","729"],"81",["9"]]]]') {
-            throw r;
-        }
-    },
-    () => {
-        let _map = ['1'];
-        for (let i = 2; i <= 28; i++)
-            _map = set(_map)((i * i).toString());
-        const r = jsonStr(_map);
-        if (r !==
-            '[[[["1"],"100",["121","144"]],"16",[["169"],"196",["225"]]],' +
-                '"25",' +
-                '[[["256"],"289",["324"],"36",["361"]],"4",[["400"],"441",["484"]]],' +
-                '"49",' +
-                '[[["529"],"576",["625"]],"64",[["676"],"729",["784"],"81",["9"]]]]') {
-            throw r;
-        }
-    },
-    () => {
-        let _map = ['1'];
-        for (let i = 2; i <= 29; i++)
-            _map = set(_map)((i * i).toString());
-        const r = jsonStr(_map);
-        if (r !==
-            '[[[["1"],"100",["121","144"]],"16",[["169"],"196",["225"]]],' +
-                '"25",' +
-                '[[["256"],"289",["324"],"36",["361"]],"4",[["400"],"441",["484"]]],' +
-                '"49",' +
-                '[[["529"],"576",["625"]],"64",[["676"],"729",["784"],"81",["841","9"]]]]') {
-            throw r;
-        }
-    },
-    () => {
-        let _map = ['1'];
-        for (let i = 2; i <= 30; i++)
-            _map = set(_map)((i * i).toString());
-        const r = jsonStr(_map);
-        if (r !==
-            '[[[["1"],"100",["121","144"]],"16",[["169"],"196",["225"]]],' +
-                '"25",' +
-                '[[["256"],"289",["324"],"36",["361"]],"4",[["400"],"441",["484"]]],' +
-                '"49",' +
-                '[[["529"],"576",["625"]],"64",[["676"],"729",["784"]],"81",[["841"],"9",["900"]]]]') {
-            throw r;
-        }
-    },
-    () => {
-        let _map = ['1'];
-        for (let i = 2; i <= 31; i++)
-            _map = set(_map)((i * i).toString());
-        const r = jsonStr(_map);
-        if (r !==
-            '[[[["1"],"100",["121","144"]],"16",[["169"],"196",["225"]]],' +
-                '"25",' +
-                '[[["256"],"289",["324"],"36",["361"]],"4",[["400"],"441",["484"]]],' +
-                '"49",' +
-                '[[["529"],"576",["625"]],"64",[["676"],"729",["784"]],"81",[["841"],"9",["900","961"]]]]') {
-            throw r;
-        }
-    },
-    () => {
-        let _map = ['1'];
-        for (let i = 2; i <= 32; i++)
-            _map = set(_map)((i * i).toString());
-        const r = jsonStr(_map);
-        if (r !==
-            '[[[["1"],"100",["1024"],"121",["144"]],"16",[["169"],"196",["225"]]],' +
-                '"25",' +
-                '[[["256"],"289",["324"],"36",["361"]],"4",[["400"],"441",["484"]]],' +
-                '"49",' +
-                '[[["529"],"576",["625"]],"64",[["676"],"729",["784"]],"81",[["841"],"9",["900","961"]]]]') {
-            throw r;
-        }
-    },
-    () => {
-        let _map = ['1'];
-        for (let i = 2; i <= 33; i++)
-            _map = set(_map)((i * i).toString());
-        const r = jsonStr(_map);
-        if (r !==
-            '[[[["1"],"100",["1024","1089"],"121",["144"]],"16",[["169"],"196",["225"]]],' +
-                '"25",' +
-                '[[["256"],"289",["324"],"36",["361"]],"4",[["400"],"441",["484"]]],' +
-                '"49",' +
-                '[[["529"],"576",["625"]],"64",[["676"],"729",["784"]],"81",[["841"],"9",["900","961"]]]]') {
-            throw r;
-        }
-    },
-    () => {
-        let _map = ['1'];
-        for (let i = 2; i <= 34; i++)
-            _map = set(_map)((i * i).toString());
-        const r = jsonStr(_map);
-        if (r !==
-            '[[[["1"],"100",["1024"]],"1089",[["1156"],"121",["144"]],"16",[["169"],"196",["225"]]],' +
-                '"25",' +
-                '[[["256"],"289",["324"],"36",["361"]],"4",[["400"],"441",["484"]]],' +
-                '"49",' +
-                '[[["529"],"576",["625"]],"64",[["676"],"729",["784"]],"81",[["841"],"9",["900","961"]]]]') {
-            throw r;
-        }
-    },
-    () => {
-        let _map = ['1'];
-        for (let i = 2; i <= 35; i++)
-            _map = set(_map)((i * i).toString());
-        const r = jsonStr(_map);
-        if (r !==
-            '[[[["1"],"100",["1024"]],"1089",[["1156"],"121",["1225","144"]],"16",[["169"],"196",["225"]]],' +
-                '"25",' +
-                '[[["256"],"289",["324"],"36",["361"]],"4",[["400"],"441",["484"]]],' +
-                '"49",' +
-                '[[["529"],"576",["625"]],"64",[["676"],"729",["784"]],"81",[["841"],"9",["900","961"]]]]') {
-            throw r;
-        }
-    },
-    () => {
-        let _map = ['1'];
-        for (let i = 2; i <= 36; i++)
-            _map = set(_map)((i * i).toString());
-        const r = jsonStr(_map);
-        if (r !==
-            '[[[["1"],"100",["1024"]],"1089",[["1156"],"121",["1225"],"1296",["144"]],"16",[["169"],"196",["225"]]],' +
-                '"25",' +
-                '[[["256"],"289",["324"],"36",["361"]],"4",[["400"],"441",["484"]]],' +
-                '"49",' +
-                '[[["529"],"576",["625"]],"64",[["676"],"729",["784"]],"81",[["841"],"9",["900","961"]]]]') {
-            throw r;
-        }
-    },
-    () => {
-        let _map = ['1'];
-        for (let i = 2; i <= 37; i++)
-            _map = set(_map)((i * i).toString());
-        const r = jsonStr(_map);
-        if (r !==
-            '[[[["1"],"100",["1024"]],"1089",[["1156"],"121",["1225"],"1296",["1369","144"]],"16",[["169"],"196",["225"]]],' +
-                '"25",' +
-                '[[["256"],"289",["324"],"36",["361"]],"4",[["400"],"441",["484"]]],' +
-                '"49",' +
-                '[[["529"],"576",["625"]],"64",[["676"],"729",["784"]],"81",[["841"],"9",["900","961"]]]]') {
-            throw r;
-        }
-    },
-    () => {
-        let _map = ['1'];
-        for (let i = 2; i <= 38; i++)
-            _map = set(_map)((i * i).toString());
-        const r = jsonStr(_map);
-        if (r !==
-            '[[[[["1"],"100",["1024"]],"1089",[["1156"],"121",["1225"]]],' +
-                '"1296",' +
-                '[[["1369"],"144",["1444"]],"16",[["169"],"196",["225"]]]],' +
-                '"25",' +
-                '[[[["256"],"289",["324"],"36",["361"]],"4",[["400"],"441",["484"]]],' +
-                '"49",' +
-                '[[["529"],"576",["625"]],"64",[["676"],"729",["784"]],"81",[["841"],"9",["900","961"]]]]]') {
-            throw r;
-        }
-    },
-    // Replacing a key already stored as a branch separator (rather than in a
-    // leaf) exercises the `x.length === 3` and `x.length === 5` arms of the
-    // "replace" case, which plain sequential inserts never reach.
-    () => {
-        let _map = ['1'];
-        for (let i = 2; i <= 10; i++)
-            _map = set(_map)((i * i).toString());
-        // top level is a Branch3 with "4" as its separator (x.length === 3)
-        assertEq(jsonStr(_map), '[[["1","100"],"16",["25","36"]],"4",[["49"],"64",["81","9"]]]');
-        const replaced = replace(_map)('4')(() => '4-updated');
-        assertEq(jsonStr(replaced), '[[["1","100"],"16",["25","36"]],"4-updated",[["49"],"64",["81","9"]]]');
-    },
-    () => {
-        let _map = ['1'];
-        for (let i = 2; i <= 13; i++)
-            _map = set(_map)((i * i).toString());
-        // top level is a Branch5 with "16" as its first separator (i === 1) and
-        // "4" as its second separator (i === 3), so both x.length === 5 replace
-        // arms are reachable from this one fixture.
-        assertEq(jsonStr(_map), '[[["1"],"100",["121","144"]],"16",[["169"],"25",["36"]],"4",[["49"],"64",["81","9"]]]');
-        const replacedFirst = replace(_map)('16')(() => '16-updated');
-        assertEq(jsonStr(replacedFirst), '[[["1"],"100",["121","144"]],"16-updated",[["169"],"25",["36"]],"4",[["49"],"64",["81","9"]]]');
-        const replacedSecond = replace(_map)('4')(() => '4-updated');
-        assertEq(jsonStr(replacedSecond), '[[["1"],"100",["121","144"]],"16",[["169"],"25",["36"]],"4-updated",[["49"],"64",["81","9"]]]');
-    }
-];
-export const proof = test;

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

@@ -1,23 +0,0 @@
-/**
- * Shared type definitions for persistent B-tree modules.
- *
- * @module
- */
-import type { Array1, Array2 } from '../../array/module.f.ts';
-export type Leaf1<T> = Array1<T>;
-export type Leaf2<T> = Array2<T>;
-export type Branch3<T> = readonly [TNode<T>, T, TNode<T>];
-export type Branch5<T> = readonly [TNode<T>, T, TNode<T>, T, TNode<T>];
-export type TNode<T> = Leaf1<T> | Leaf2<T> | Branch3<T> | Branch5<T>;
-export type Tree<T> = TNode<T> | null;
-export type Branch1<T> = readonly [TNode<T>];
-export type Branch7<T> = readonly [...Branch5<T>, T, TNode<T>];
-/**
- * Demotes a single-child branch root to its only child.
- *
- * After an insert or remove the root may temporarily hold exactly one child
- * (a `Branch1`). In that case the tree is one level taller than necessary;
- * returning the child directly restores the correct height. If the root has
- * more than one child it is returned unchanged.
- */
-export declare const collapseRoot: <T>(b: Branch1<T> | Branch3<T> | Branch5<T>) => TNode<T>;

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

@@ -1,9 +0,0 @@
-/**
- * Demotes a single-child branch root to its only child.
- *
- * After an insert or remove the root may temporarily hold exactly one child
- * (a `Branch1`). In that case the tree is one level taller than necessary;
- * returning the child directly restores the correct height. If the root has
- * more than one child it is returned unchanged.
- */
-export const collapseRoot = b => b.length === 1 ? b[0] : b;

package/fjs/types/byte_set/module.f.d.ts

@@ -1,16 +0,0 @@
-import type { RangeMap } from '../range_map/module.f.ts';
-import type { SortedSet } from '../sorted_set/module.f.ts';
-export type ByteSet = bigint;
-type Byte = number;
-export declare const has: (n: Byte) => (s: ByteSet) => boolean;
-export declare const empty = 0n;
-export declare const universe = 115792089237316195423570985008687907853269984665640564039457584007913129639935n;
-export declare const one: (n: Byte) => ByteSet;
-export declare const range: (r: readonly [Byte, Byte]) => ByteSet;
-export declare const union: (a: ByteSet) => (b: ByteSet) => ByteSet;
-export declare const complement: (n: ByteSet) => ByteSet;
-export declare const set: (_: number) => (b: ByteSet) => ByteSet;
-export declare const setRange: (_: readonly [number, number]) => (b: ByteSet) => ByteSet;
-export declare const unset: (n: Byte) => (s: ByteSet) => ByteSet;
-export declare const toRangeMap: (n: ByteSet) => (s: string) => RangeMap<SortedSet<string>>;
-export {};

package/fjs/types/byte_set/module.f.js

@@ -1,30 +0,0 @@
-/**
- * Compact byte-set operations and predicates.
- *
- * @module
- */
-import { compose } from '../function/module.f.js';
-import { reverse, countdown, flat, map } from '../list/module.f.js';
-export const has = n => s => ((s >> BigInt(n)) & 1n) === 1n;
-// create a set
-export const empty = 0n;
-//                        0    1    2    3    4    5    6    7    8    9    A    B    C    D    E    F
-export const universe = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn;
-export const one = n => 1n << BigInt(n);
-export const range = ([b, e]) => one(e - b + 1) - 1n << BigInt(b);
-// set operations
-export const union = a => b => a | b;
-const intersect = a => b => a & b;
-export const complement = n => universe ^ n;
-const difference = compose(intersect)(compose(complement));
-// additional operations
-export const set = compose(one)(union);
-export const setRange = compose(range)(union);
-export const unset = n => s => difference(s)(one(n));
-const counter = reverse(countdown(256));
-const toRangeMapOp = n => s => i => {
-    const current = has(i + 1)(n);
-    const prev = has(i)(n);
-    return current === prev ? null : [[prev ? [s] : [], i]];
-};
-export const toRangeMap = n => s => flat(map(toRangeMapOp(n)(s))(counter));

package/fjs/types/byte_set/proof.f.d.ts

@@ -1,11 +0,0 @@
-export declare const proof: {
-    has: (() => void)[];
-    setRange: () => void;
-    unset: (() => void)[];
-    universe: () => void;
-    compliment: {
-        empty: () => void;
-        universe: () => void;
-    };
-    toRangeMap: (() => void)[];
-};

package/fjs/types/byte_set/proof.f.js

@@ -1,79 +0,0 @@
-import { has, empty, set, setRange, unset, universe, complement, toRangeMap } from './module.f.js';
-import { every, countdown, map, toArray } from '../list/module.f.js';
-import { stringify as jsonStringify } from '../../media/json/module.f.js';
-import { sort } from '../object/module.f.js';
-import { assert, assertEq } from '../../asserts/module.f.js';
-const stringify = jsonStringify(sort);
-export const proof = {
-    has: [
-        () => {
-            assert(!(has(0)(empty)), empty);
-            assert(!(has(1)(empty)), empty);
-            assert(!(has(33)(empty)), empty);
-        },
-        () => {
-            const s = set(0)(empty);
-            assertEq(s, 1n);
-            assert(has(0)(s), s);
-            assert(!(has(1)(s)), s);
-            assert(!(has(33)(s)), s);
-        },
-        () => {
-            const s = set(33)(empty);
-            assertEq(s, 8589934592n);
-            assert(!(has(0)(s)), s);
-            assert(!(has(1)(s)), s);
-            assert(has(33)(s), s);
-        }
-    ],
-    setRange: () => {
-        const result = setRange([2, 5])(empty);
-        assertEq(result, 60n);
-    },
-    unset: [
-        () => {
-            const a = set(0)(empty);
-            const result = unset(0)(a);
-            assertEq(result, 0n);
-        },
-        () => {
-            const a = set(255)(empty);
-            const result = unset(255)(a);
-            assertEq(result, 0n);
-        }
-    ],
-    universe: () => {
-        const x = every(map((v) => has(v)(universe))(countdown(256)));
-        assert(x, x);
-    },
-    compliment: {
-        empty: () => {
-            const r = complement(empty);
-            assertEq(r, universe);
-        },
-        universe: () => {
-            const r = complement(universe);
-            assertEq(r, empty);
-        },
-    },
-    toRangeMap: [
-        () => {
-            const result = stringify(toArray(toRangeMap(empty)('a')));
-            assertEq(result, '[]');
-        },
-        () => {
-            const s = set(0)(empty);
-            const result = stringify(toArray(toRangeMap(s)('a')));
-            assertEq(result, '[[["a"],0]]');
-        },
-        () => {
-            const s = setRange([1, 2])(empty);
-            const result = stringify(toArray(toRangeMap(s)('a')));
-            assertEq(result, '[[[],0],[["a"],2]]');
-        },
-        () => {
-            const result = stringify(toArray(toRangeMap(universe)('a')));
-            assertEq(result, '[[["a"],255]]');
-        },
-    ]
-};

package/fjs/types/function/compare/module.f.d.ts

@@ -1,49 +0,0 @@
-/**
- * Comparison function types and helpers.
- *
- * @module
- */
-import type { Index3, Index5, Array2 } from '../../array/module.f.ts';
-export type Sign = -1 | 0 | 1;
-export type Compare<T> = (_: T) => Sign;
-export type Cmp<T> = (a: T) => Compare<T>;
-export declare const index3: <T>(cmp: Compare<T>) => (value: T) => Index3;
-export declare const index5: <T>(cmp: Compare<T>) => (v2: Array2<T>) => Index5;
-export type Cmp1 = boolean | string | number | bigint;
-export type Cmp2<A, B> = [
-    A,
-    B
-] extends [boolean, boolean] ? boolean : [
-    A,
-    B
-] extends [string, string] ? string : [
-    A,
-    B
-] extends [number, number] ? number : [
-    A,
-    B
-] extends [bigint, bigint] ? bigint : never;
-export declare const cmp: <A extends Cmp1>(a: A) => <B extends Cmp2<A, B>>(b: B) => Sign;
-/**
- * Returns the smaller of two comparable values. The `Cmp2<A, B>` constraint
- * is the same one `cmp` uses: it rejects calls that mix incompatible primitive
- * types (e.g. `min(1)("a")`) at compile time.
- */
-export declare const min: <A extends Cmp1>(a: A) => <B extends Cmp2<A, B>>(b: B) => A | B;
-/**
- * Returns the larger of two comparable values. The `Cmp2<A, B>` constraint
- * is the same one `cmp` uses: it rejects calls that mix incompatible primitive
- * types (e.g. `max(1)("a")`) at compile time.
- */
-export declare const max: <A extends Cmp1>(a: A) => <B extends Cmp2<A, B>>(b: B) => A | B;
-/**
- * Binary search over `[0, len)`. `probe(mid)` returns the sign of the search
- * key relative to the element at `mid` (`-1` before, `0` at, `1` after). On a
- * hit it returns the matching index; on a miss it returns the converged lower
- * bound `b` (the insertion point), which may equal `len`.
- *
- * `probe` must be monotonic over `[0, len)`: scanning indices left to right its
- * result is non-increasing — a run of `1`s, then `0`s, then `-1`s. A
- * non-monotonic probe yields an undefined position.
- */
-export declare const bsearch: (len: number) => (probe: (mid: number) => Sign) => number;

package/fjs/types/function/compare/module.f.js

@@ -1,51 +0,0 @@
-export const index3 = cmp => value => (cmp(value) + 1);
-export const index5 = cmp => ([v0, v1]) => {
-    const _0 = cmp(v0);
-    return (_0 <= 0 ? _0 + 1 : cmp(v1) + 3);
-};
-export const cmp = (a) => (b) => a < b ? -1 : a > b ? 1 : 0;
-/**
- * Returns the smaller of two comparable values. The `Cmp2<A, B>` constraint
- * is the same one `cmp` uses: it rejects calls that mix incompatible primitive
- * types (e.g. `min(1)("a")`) at compile time.
- */
-export const min = (a) => (b) => cmp(a)(b) < 0 ? a : b;
-/**
- * Returns the larger of two comparable values. The `Cmp2<A, B>` constraint
- * is the same one `cmp` uses: it rejects calls that mix incompatible primitive
- * types (e.g. `max(1)("a")`) at compile time.
- */
-export const max = (a) => (b) => cmp(a)(b) > 0 ? a : b;
-/**
- * Binary search over `[0, len)`. `probe(mid)` returns the sign of the search
- * key relative to the element at `mid` (`-1` before, `0` at, `1` after). On a
- * hit it returns the matching index; on a miss it returns the converged lower
- * bound `b` (the insertion point), which may equal `len`.
- *
- * `probe` must be monotonic over `[0, len)`: scanning indices left to right its
- * result is non-increasing — a run of `1`s, then `0`s, then `-1`s. A
- * non-monotonic probe yields an undefined position.
- */
-export const bsearch = (len) => (probe) => {
-    let b = 0;
-    let e = len - 1;
-    while (true) {
-        if (e < b) {
-            return b;
-        }
-        const mid = b + (e - b >> 1);
-        switch (probe(mid)) {
-            case -1: {
-                e = mid - 1;
-                break;
-            }
-            case 0: {
-                return mid;
-            }
-            case 1: {
-                b = mid + 1;
-                break;
-            }
-        }
-    }
-};