functionalscript 0.2.5 → 0.3.0

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

@@ -1,19 +0,0 @@
-/** @type {<T>(op: Operators<T>) => RangeMerge<T>} */
-export const merge: <T>(op: Operators<T>) => RangeMerge<T>;
-/** @type {<T>(def: T) => (value: number) => (rm: RangeMapArray<T>) => T} */
-export const get: <T>(def: T) => (value: number) => (rm: RangeMapArray<T>) => T;
-/** @type {<T>(def: T) => (r: Range.Range) => (value: T) => RangeMapArray<T>} */
-export const fromRange: <T>(def: T) => (r: Range.Range) => (value: T) => RangeMapArray<T>;
-export type Entry<T> = [T, number];
-export type RangeMap<T> = sortedList.SortedList<Entry<T>>;
-export type RangeMapArray<T> = readonly Entry<T>[];
-export type Operators<T> = {
-    readonly union: O.Reduce<T>;
-    readonly equal: O.Equal<T>;
-};
-export type RangeState<T> = Option.Nullable<Entry<T>>;
-export type RangeMerge<T> = O.Reduce<RangeMap<T>>;
-import * as Range from '../range/module.f.mjs';
-import * as sortedList from '../sorted_list/module.f.mjs';
-import * as O from '../function/operator/module.f.mjs';
-import * as Option from '../nullable/module.f.mjs';

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

@@ -1,84 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-import * as sortedList from '../sorted_list/module.f.mjs';
-const { genericMerge } = sortedList;
-import * as list from '../list/module.f.mjs';
-const { next } = list;
-import * as Option from '../nullable/module.f.mjs';
-import * as number from '../number/module.f.mjs';
-const { cmp } = number;
-import * as O from '../function/operator/module.f.mjs';
-import * as Range from '../range/module.f.mjs';
-/**
- * @template T
- * @typedef {[T, number]} Entry
- */
-/**
- * @template T
- * @typedef {sortedList.SortedList<Entry<T>>} RangeMap
- */
-/**
- * @template T
- * @typedef {readonly Entry<T>[]} RangeMapArray
- */
-/**
- * @template T
- * @typedef {{
- *  readonly union: O.Reduce<T>
- *  readonly equal: O.Equal<T>
- * }} Operators
- */
-/**
- * @template T
- * @typedef {Option.Nullable<Entry<T>>} RangeState
- */
-/**
- * @template T
- * @typedef {O.Reduce<RangeMap<T>>} RangeMerge
- */
-/** @type {<T>(union: O.Reduce<T>) => (equal: O.Equal<T>) => sortedList.ReduceOp<Entry<T>, RangeState<T>>} */
-const reduceOp = 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]];
-};
-/** @type {<T>(equal: O.Equal<T>) => sortedList.TailReduce<Entry<T>, RangeState<T>>} */
-const tailReduce = 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 };
-};
-/** @type {<T>(op: Operators<T>) => RangeMerge<T>} */
-export const merge = ({ union, equal }) => genericMerge({ reduceOp: reduceOp(union)(equal), tailReduce: tailReduce(equal) })(null);
-/** @type {<T>(def: T) => (value: number) => (rm: RangeMapArray<T>) => T} */
-export const get = def => value => rm => {
-    const len = rm.length;
-    let b = 0;
-    let e = len - 1;
-    while (true) {
-        if (b >= len) {
-            return def;
-        }
-        if (e - b < 0) {
-            return rm[b][0];
-        }
-        const mid = b + (e - b >> 1);
-        if (value <= rm[mid][1]) {
-            e = mid - 1;
-        }
-        else {
-            b = mid + 1;
-        }
-    }
-};
-/** @type {<T>(def: T) => (r: Range.Range) => (value: T) => RangeMapArray<T>} */
-export const fromRange = def => ([a, b]) => v => [[def, a - 1], [v, b]];

package/out/types/range_map/test.f.d.mts

@@ -1,6 +0,0 @@
-declare namespace _default {
-    let merge: (() => void)[];
-    function get(): (() => void)[];
-    function fromRange(): (() => void)[];
-}
-export default _default;

package/out/types/range_map/test.f.mjs

@@ -1,201 +0,0 @@
-import * as _ from './module.f.mjs';
-import * as compare from '../function/compare/module.f.mjs';
-const { unsafeCmp } = compare;
-import * as json from '../../json/module.f.mjs';
-import * as object from '../object/module.f.mjs';
-const { sort } = object;
-import * as sortedSet from '../sorted_set/module.f.mjs';
-import * as list from '../list/module.f.mjs';
-import * as operator from '../function/operator/module.f.mjs';
-/** @type {(a: readonly json.Unknown[]) => string} */
-const stringify = json.stringify(sort);
-/** @type {_.Operators<sortedSet.SortedSet<string>>} */
-const op = { union: sortedSet.union(unsafeCmp), equal: list.equal(operator.strictEqual) };
-export default {
-    merge: [
-        () => {
-            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
-            const a = [[['a'], 1], [['b'], 2]];
-            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
-            const b = null;
-            const merged = _.merge(op)(a)(b);
-            const result = stringify(list.toArray(merged));
-            if (result !== '[[["a"],1],[["b"],2]]') {
-                throw result;
-            }
-        },
-        () => {
-            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
-            const a = null;
-            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
-            const b = [[['a'], 1], [['b'], 2]];
-            const merged = _.merge(op)(a)(b);
-            const result = stringify(list.toArray(merged));
-            if (result !== '[[["a"],1],[["b"],2]]') {
-                throw result;
-            }
-        },
-        () => {
-            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
-            const a = [[['a'], 1], [['b'], 2]];
-            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
-            const b = [[['a'], 1], [['b'], 2]];
-            const merged = _.merge(op)(a)(b);
-            const result = stringify(list.toArray(merged));
-            if (result !== '[[["a"],1],[["b"],2]]') {
-                throw result;
-            }
-        },
-        () => {
-            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
-            const a = [[['a'], 1], [['c'], 3]];
-            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
-            const b = [[['b'], 2], [['d'], 4]];
-            const merged = _.merge(op)(a)(b);
-            const result = stringify(list.toArray(merged));
-            if (result !== '[[["a","b"],1],[["b","c"],2],[["c","d"],3],[["d"],4]]') {
-                throw result;
-            }
-        },
-        () => {
-            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
-            const a = [[['a'], 1], [['d'], 4]];
-            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
-            const b = [[['b'], 2], [['c'], 3]];
-            const merged = _.merge(op)(a)(b);
-            const result = stringify(list.toArray(merged));
-            if (result !== '[[["a","b"],1],[["b","d"],2],[["c","d"],3],[["d"],4]]') {
-                throw result;
-            }
-        },
-        () => {
-            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
-            const a = [[['a'], 1], [['b'], 2]];
-            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
-            const b = [[['b'], 1], [['a'], 2]];
-            const merged = _.merge(op)(a)(b);
-            const result = stringify(list.toArray(merged));
-            if (result !== '[[["a","b"],2]]') {
-                throw result;
-            }
-        },
-        () => {
-            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
-            const a = [[['a'], 1], [['b'], 2], [['a'], 3]];
-            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
-            const b = [[['a'], 5]];
-            const merged = _.merge(op)(a)(b);
-            const result = stringify(list.toArray(merged));
-            if (result !== '[[["a"],1],[["a","b"],2],[["a"],5]]') {
-                throw result;
-            }
-        }
-    ],
-    get: () => {
-        /** @type {sortedSet.SortedSet<string>} */
-        const sortedSetEmpty = [];
-        const get = _.get(sortedSetEmpty);
-        return [
-            () => {
-                /** @type {_.RangeMapArray<sortedSet.SortedSet<string>>} */
-                const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
-                const result = stringify(get(5)(rm));
-                if (result !== '["a"]') {
-                    throw result;
-                }
-            },
-            () => {
-                /** @type {_.RangeMapArray<sortedSet.SortedSet<string>>} */
-                const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
-                const result = stringify(get(10)(rm));
-                if (result !== '["a"]') {
-                    throw result;
-                }
-            },
-            () => {
-                /** @type {_.RangeMapArray<sortedSet.SortedSet<string>>} */
-                const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
-                const result = stringify(get(15)(rm));
-                if (result !== '["b"]') {
-                    throw result;
-                }
-            },
-            () => {
-                /** @type {_.RangeMapArray<sortedSet.SortedSet<string>>} */
-                const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
-                const result = stringify(get(20)(rm));
-                if (result !== '["b"]') {
-                    throw result;
-                }
-            },
-            () => {
-                /** @type {_.RangeMapArray<sortedSet.SortedSet<string>>} */
-                const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
-                const result = stringify(get(25)(rm));
-                if (result !== '["c"]') {
-                    throw result;
-                }
-            },
-            () => {
-                /** @type {_.RangeMapArray<sortedSet.SortedSet<string>>} */
-                const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
-                const result = stringify(get(30)(rm));
-                if (result !== '["c"]') {
-                    throw result;
-                }
-            },
-            () => {
-                /** @type {_.RangeMapArray<sortedSet.SortedSet<string>>} */
-                const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
-                const result = stringify(get(35)(rm));
-                if (result !== '[]') {
-                    throw result;
-                }
-            },
-            () => {
-                /** @type {_.RangeMapArray<sortedSet.SortedSet<string>>} */
-                const rm = [];
-                const result = stringify(get(10)(rm));
-                if (result !== '[]') {
-                    throw result;
-                }
-            }
-        ];
-    },
-    fromRange: () => {
-        const def = -1;
-        const rm = _.fromRange(def)([1, 7])(42);
-        return [
-            () => {
-                const result = _.get(def)(0)(rm);
-                if (result !== -1) {
-                    throw result;
-                }
-            },
-            () => {
-                const result = _.get(def)(1)(rm);
-                if (result !== 42) {
-                    throw result;
-                }
-            },
-            () => {
-                const result = _.get(def)(3)(rm);
-                if (result !== 42) {
-                    throw result;
-                }
-            },
-            () => {
-                const result = _.get(def)(7)(rm);
-                if (result !== 42) {
-                    throw result;
-                }
-            },
-            () => {
-                const result = _.get(def)(9)(rm);
-                if (result !== -1) {
-                    throw result;
-                }
-            },
-        ];
-    }
-};

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

@@ -1,7 +0,0 @@
-declare namespace _default {
-    export { tryCatch };
-}
-export default _default;
-/** @type {<T>(f: () => T) => result.Result<T, unknown>} */
-declare const tryCatch: <T>(f: () => T) => result.Result<T, unknown>;
-import * as result from './module.f.mjs';

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

@@ -1,22 +0,0 @@
-/**
- * @template T
- * @typedef {readonly['ok', T]} Ok
- */
-/**
- * @template E
- * @typedef {readonly['error', E]} Error
- */
-/**
- * @template T
- * @template E
- * @typedef {Ok<T>|Error<E>} Result
- */
-/** @type {<T>(value: T) => Ok<T>} */
-export const ok: <T>(value: T) => Ok<T>;
-/** @type {<E>(e: E) => Error<E>} */
-export const error: <E>(e: E) => Error<E>;
-/** @type {<T, E>(r: Result<T, E>) => T} */
-export const unwrap: <T, E>(r: Result<T, E>) => T;
-export type Ok<T> = readonly ["ok", T];
-export type Error<E> = readonly ["error", E];
-export type Result<T, E> = Ok<T> | Error<E>;

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

@@ -1,25 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-/**
- * @template T
- * @typedef {readonly['ok', T]} Ok
- */
-/**
- * @template E
- * @typedef {readonly['error', E]} Error
- */
-/**
- * @template T
- * @template E
- * @typedef {Ok<T>|Error<E>} Result
- */
-/** @type {<T>(value: T) => Ok<T>} */
-export const ok = value => ['ok', value];
-/** @type {<E>(e: E) => Error<E>} */
-export const error = e => ['error', e];
-/** @type {<T, E>(r: Result<T, E>) => T} */
-export const unwrap = ([kind, v]) => {
-    if (kind === 'error') {
-        throw v;
-    }
-    return v;
-};

package/out/types/result/module.mjs

@@ -1,16 +0,0 @@
-import * as result from './module.f.mjs';
-const { ok, error } = result;
-/** @type {<T>(f: () => T) => result.Result<T, unknown>} */
-const tryCatch = f => {
-    // Side effect: `try catch` is not allowed in FunctionalScript.
-    try {
-        return ok(f());
-    }
-    catch (e) {
-        return error(e);
-    }
-};
-export default {
-    /** @readonly */
-    tryCatch,
-};

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

@@ -1,53 +0,0 @@
-/**
- * @template T
- * @typedef {list.List<T>} SortedList
- */
-/**
- * @template T
- * @typedef {readonly T[]} SortedArray
- */
-/**
- * @template T
- * @typedef {(a: T) => (b: T) => compare.Sign} Cmp
- */
-/**
- * @template T
- * @template S
- * @typedef {(state: S) => (a: T) => (b: T) => readonly[option.Nullable<T>, compare.Sign, S]} ReduceOp
- */
-/**
- * @template T
- * @template S
- * @typedef {(state: S) => (tail: list.List<T>) => list.List<T>} TailReduce
- */
-/**
- * @template T
- * @template S
-  * @typedef {{
- *  readonly reduceOp: ReduceOp<T,S>
- *  readonly tailReduce: TailReduce<T,S>
-  * }} MergeReduce
- */
-/** @type {<T,S>(reduce: MergeReduce<T,S>) => (state: S) => (a: list.List<T>) => (b: list.List<T>) => list.List<T>} */
-export const genericMerge: <T, S>(reduce: MergeReduce<T, S>) => (state: S) => (a: list.List<T>) => (b: list.List<T>) => list.List<T>;
-/**
- * @template T
- * @typedef {ReduceOp<T, null>} CmpReduceOp
- */
-/** @type {<T>(cmp: Cmp<T>) => (a: SortedList<T>) => (b: SortedList<T>) => SortedList<T>} */
-export const merge: <T>(cmp: Cmp<T>) => (a: SortedList<T>) => (b: SortedList<T>) => SortedList<T>;
-/** @type {<T>(cmp: Cmp<T>) => (value: T) => (array: SortedArray<T>) =>  T|null} */
-export const find: <T>(cmp: Cmp<T>) => (value: T) => (array: SortedArray<T>) => T | null;
-export type SortedList<T> = list.List<T>;
-export type SortedArray<T> = readonly T[];
-export type Cmp<T> = (a: T) => (b: T) => compare.Sign;
-export type ReduceOp<T, S> = (state: S) => (a: T) => (b: T) => readonly [option.Nullable<T>, compare.Sign, S];
-export type TailReduce<T, S> = (state: S) => (tail: list.List<T>) => list.List<T>;
-export type MergeReduce<T, S> = {
-    readonly reduceOp: ReduceOp<T, S>;
-    readonly tailReduce: TailReduce<T, S>;
-};
-export type CmpReduceOp<T> = ReduceOp<T, null>;
-import * as list from '../list/module.f.mjs';
-import * as compare from '../function/compare/module.f.mjs';
-import * as option from '../nullable/module.f.mjs';

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

@@ -1,102 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-import * as compare from '../function/compare/module.f.mjs';
-import * as list from '../list/module.f.mjs';
-import * as option from '../nullable/module.f.mjs';
-const { next } = list;
-import * as f from '../function/module.f.mjs';
-const { identity } = f;
-/**
- * @template T
- * @typedef {list.List<T>} SortedList
- */
-/**
- * @template T
- * @typedef {readonly T[]} SortedArray
- */
-/**
- * @template T
- * @typedef {(a: T) => (b: T) => compare.Sign} Cmp
- */
-/**
- * @template T
- * @template S
- * @typedef {(state: S) => (a: T) => (b: T) => readonly[option.Nullable<T>, compare.Sign, S]} ReduceOp
- */
-/**
- * @template T
- * @template S
- * @typedef {(state: S) => (tail: list.List<T>) => list.List<T>} TailReduce
- */
-/**
- * @template T
- * @template S
-  * @typedef {{
- *  readonly reduceOp: ReduceOp<T,S>
- *  readonly tailReduce: TailReduce<T,S>
-  * }} MergeReduce
- */
-/** @type {<T,S>(reduce: MergeReduce<T,S>) => (state: S) => (a: list.List<T>) => (b: list.List<T>) => list.List<T>} */
-export const genericMerge = ({ reduceOp, tailReduce }) => {
-    /** @typedef {typeof reduceOp extends ReduceOp<infer T, infer S> ? [T, S] : never} TS */
-    /** @typedef {TS[0]} T */
-    /** @typedef {TS[1]} S */
-    /** @type {(state: S) => (a: list.List<T>) => (b: list.List<T>) => list.List<T>} */
-    const f = state => a => b => () => {
-        const aResult = next(a);
-        if (aResult === null) {
-            return tailReduce(state)(b);
-        }
-        const bResult = next(b);
-        if (bResult === null) {
-            return tailReduce(state)(aResult);
-        }
-        const [first, sign, stateNext] = reduceOp(state)(aResult.first)(bResult.first);
-        const aNext = sign === 1 ? a : aResult.tail;
-        const bNext = sign === -1 ? b : bResult.tail;
-        const tail = f(stateNext)(aNext)(bNext);
-        return first === null ? tail : { first, tail };
-    };
-    return f;
-};
-/**
- * @template T
- * @typedef {ReduceOp<T, null>} CmpReduceOp
- */
-/** @type {<T>(cmp: Cmp<T>) => (a: SortedList<T>) => (b: SortedList<T>) => SortedList<T>} */
-export const merge = cmp => {
-    /** @typedef {typeof cmp extends Cmp<infer T> ? T : never} T*/
-    /** @type {TailReduce<T, null>} */
-    const tailReduce = mergeTail;
-    return genericMerge({ reduceOp: cmpReduce(cmp), tailReduce })(null);
-};
-/** @type {<T>(cmp: Cmp<T>) => CmpReduceOp<T>} */
-const cmpReduce = cmp => () => a => b => {
-    const sign = cmp(a)(b);
-    return [sign === 1 ? b : a, sign, null];
-};
-/** @type {() => <T>(tail: list.List<T>) => list.List<T>} */
-const mergeTail = () => identity;
-/** @type {<T>(cmp: Cmp<T>) => (value: T) => (array: SortedArray<T>) =>  T|null} */
-export const find = cmp => value => array => {
-    let b = 0;
-    let e = array.length - 1;
-    while (true) {
-        if (e - b < 0)
-            return null;
-        const mid = b + (e - b >> 1);
-        const sign = cmp(value)(array[mid]);
-        switch (sign) {
-            case -1: {
-                e = mid - 1;
-                break;
-            }
-            case 0: {
-                return value;
-            }
-            case 1: {
-                b = mid + 1;
-                break;
-            }
-        }
-    }
-};

package/out/types/sorted_list/test.f.d.mts

@@ -1,5 +0,0 @@
-declare namespace _default {
-    let sortedMergre: (() => void)[];
-    let find: (() => void)[];
-}
-export default _default;

package/out/types/sorted_list/test.f.mjs

@@ -1,66 +0,0 @@
-import * as _ from './module.f.mjs';
-import * as compare from '../function/compare/module.f.mjs';
-const { unsafeCmp } = compare;
-import * as json from '../../json/module.f.mjs';
-import * as object from '../object/module.f.mjs';
-const { sort } = object;
-import * as list from '../list/module.f.mjs';
-const { toArray, countdown, length } = list;
-import * as Map from '../map/module.f.mjs';
-import * as f from '../function/module.f.mjs';
-const { flip } = f;
-/** @type {(a: readonly json.Unknown[]) => string} */
-const stringify = json.stringify(sort);
-/** @type {<T>(a: T) => (b: T) => Map.Sign} */
-const reverseCmp = flip(unsafeCmp);
-export default {
-    sortedMergre: [
-        () => {
-            const result = stringify(toArray(_.merge(unsafeCmp)([2, 3, 4])([1, 3, 5])));
-            if (result !== '[1,2,3,4,5]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(toArray(_.merge(unsafeCmp)([1, 2, 3])([])));
-            if (result !== '[1,2,3]') {
-                throw result;
-            }
-        },
-        () => {
-            const n = 10_000;
-            const list = countdown(n);
-            const result = _.merge(reverseCmp)(list)(list);
-            const len = length(result);
-            if (len != n) {
-                throw result;
-            }
-        }
-    ],
-    find: [
-        () => {
-            const result = _.find(unsafeCmp)(0)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
-            if (result !== 0) {
-                throw result;
-            }
-        },
-        () => {
-            const result = _.find(unsafeCmp)(3)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
-            if (result !== null) {
-                throw result;
-            }
-        },
-        () => {
-            const result = _.find(unsafeCmp)(77)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
-            if (result !== null) {
-                throw result;
-            }
-        },
-        () => {
-            const result = _.find(unsafeCmp)(80)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
-            if (result !== 80) {
-                throw result;
-            }
-        }
-    ]
-};

package/out/types/sorted_set/module.f.d.mts

@@ -1,19 +0,0 @@
-/**
- * @template T
- * @typedef {readonly T[]} SortedSet
- */
-/**
- * @template T
- * @typedef {(a: T) => (b: T) => Compare.Sign} Cmp
- */
-/** @typedef {number} Byte */
-/** @type {<T>(cmp: Cmp<T>) => (a: SortedSet<T>) => (b: SortedSet<T>) => SortedSet<T>} */
-export const union: <T>(cmp: Cmp<T>) => (a: SortedSet<T>) => (b: SortedSet<T>) => SortedSet<T>;
-/** @type {<T>(cmp: Cmp<T>) => (a: SortedSet<T>) => (b: SortedSet<T>) => SortedSet<T>} */
-export const intersect: <T>(cmp: Cmp<T>) => (a: SortedSet<T>) => (b: SortedSet<T>) => SortedSet<T>;
-/** @type {<T>(cmp: Cmp<T>) => (value: T) => (set: SortedSet<T>) => boolean} */
-export const has: <T>(cmp: Cmp<T>) => (value: T) => (set: SortedSet<T>) => boolean;
-export type SortedSet<T> = readonly T[];
-export type Cmp<T> = (a: T) => (b: T) => Compare.Sign;
-export type Byte = number;
-import * as Compare from '../function/compare/module.f.mjs';

package/out/types/sorted_set/module.f.mjs

@@ -1,29 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-import * as Compare from '../function/compare/module.f.mjs';
-import * as list from "../list/module.f.mjs";
-const { toArray } = list;
-import * as sortedList from '../sorted_list/module.f.mjs';
-const { merge, genericMerge, find } = sortedList;
-/**
- * @template T
- * @typedef {readonly T[]} SortedSet
- */
-/**
- * @template T
- * @typedef {(a: T) => (b: T) => Compare.Sign} Cmp
- */
-/** @typedef {number} Byte */
-/** @type {<T>(cmp: Cmp<T>) => (a: SortedSet<T>) => (b: SortedSet<T>) => SortedSet<T>} */
-export const union = cmp => a => b => toArray(merge(cmp)(a)(b));
-/** @type {<T>(cmp: Cmp<T>) => (a: SortedSet<T>) => (b: SortedSet<T>) => SortedSet<T>} */
-export const intersect = cmp => a => b => toArray(intersectMerge(cmp)(a)(b));
-const tailReduce = () => () => null;
-/** @type {<T>(cmp: Cmp<T>) => (a: sortedList.SortedList<T>) => (b: sortedList.SortedList<T>) => sortedList.SortedList<T>} */
-const intersectMerge = cmp => genericMerge({ reduceOp: intersectReduce(cmp), tailReduce })(null);
-/** @type {<T,S>(cmp: Cmp<T>) => sortedList.ReduceOp<T,S>} */
-const intersectReduce = cmp => state => a => b => {
-    const sign = cmp(a)(b);
-    return [sign === 0 ? a : null, sign, state];
-};
-/** @type {<T>(cmp: Cmp<T>) => (value: T) => (set: SortedSet<T>) => boolean} */
-export const has = cmp => value => set => find(cmp)(value)(set) === value;

package/out/types/sorted_set/test.f.d.mts

@@ -1,6 +0,0 @@
-declare namespace _default {
-    let union: (() => void)[];
-    let intersect: (() => void)[];
-    let has: (() => void)[];
-}
-export default _default;