functionalscript 0.1.609 → 0.2.1

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

@@ -0,0 +1,84 @@
+// @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.mjs

@@ -0,0 +1,201 @@
+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

@@ -0,0 +1,7 @@
+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/{types → out/types}/result/module.f.d.mts

@@ -1,12 +1,3 @@
-declare namespace _default {
-    export { ok };
-    export { error };
-    export { unwrap };
-}
-export default _default;
-export type Ok<T> = readonly ["ok", T];
-export type Error<E> = readonly ["error", E];
-export type Result<T, E> = Ok<T> | Error<E>;
 /**
  * @template T
  * @typedef {readonly['ok', T]} Ok
@@ -21,8 +12,11 @@ export type Result<T, E> = Ok<T> | Error<E>;
  * @typedef {Ok<T>|Error<E>} Result
  */
 /** @type {<T>(value: T) => Ok<T>} */
-declare const ok: <T>(value: T) => Ok<T>;
+export const ok: <T>(value: T) => Ok<T>;
 /** @type {<E>(e: E) => Error<E>} */
-declare const error: <E>(e: E) => Error<E>;
+export const error: <E>(e: E) => Error<E>;
 /** @type {<T, E>(r: Result<T, E>) => T} */
-declare const unwrap: <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

@@ -0,0 +1,25 @@
+// @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

@@ -0,0 +1,16 @@
+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/{types → out/types}/sorted_list/module.f.d.mts

@@ -1,28 +1,6 @@
-declare namespace _default {
-    export { merge };
-    export { genericMerge };
-    export { find };
-}
-export default _default;
-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>;
-/**
- * @template T
- * @typedef {ReduceOp<T, null>} CmpReduceOp
- */
-/** @type {<T>(cmp: Cmp<T>) => (a: SortedList<T>) => (b: SortedList<T>) => SortedList<T>} */
-declare const merge: <T>(cmp: Cmp<T>) => (a: SortedList<T>) => (b: SortedList<T>) => SortedList<T>;
 /**
  * @template T
- * @typedef {List.List<T>} SortedList
+ * @typedef {list.List<T>} SortedList
  */
 /**
  * @template T
@@ -40,7 +18,7 @@ declare const merge: <T>(cmp: Cmp<T>) => (a: SortedList<T>) => (b: SortedList<T>
 /**
  * @template T
  * @template S
- * @typedef {(state: S) => (tail: List.List<T>) => List.List<T>} TailReduce
+ * @typedef {(state: S) => (tail: list.List<T>) => list.List<T>} TailReduce
  */
 /**
  * @template T
@@ -50,10 +28,26 @@ declare const merge: <T>(cmp: Cmp<T>) => (a: SortedList<T>) => (b: SortedList<T>
  *  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>} */
-declare const genericMerge: <T, S>(reduce: MergeReduce<T, S>) => (state: S) => (a: List.List<T>) => (b: List.List<T>) => List.List<T>;
+/** @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} */
-declare const find: <T>(cmp: Cmp<T>) => (value: T) => (array: SortedArray<T>) => T | null;
-import * as List from '../list/module.f.mjs';
+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

@@ -0,0 +1,102 @@
+// @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.mjs

@@ -0,0 +1,66 @@
+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/{types → out/types}/sorted_set/module.f.d.mts

@@ -1,12 +1,3 @@
-declare namespace _default {
-    export { union };
-    export { intersect };
-    export { has };
-}
-export default _default;
-export type SortedSet<T> = readonly T[];
-export type Cmp<T> = (a: T) => (b: T) => Compare.Sign;
-export type Byte = number;
 /**
  * @template T
  * @typedef {readonly T[]} SortedSet
@@ -17,9 +8,12 @@ export type Byte = number;
  */
 /** @typedef {number} Byte */
 /** @type {<T>(cmp: Cmp<T>) => (a: SortedSet<T>) => (b: SortedSet<T>) => SortedSet<T>} */
-declare const union: <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>} */
-declare const intersect: <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} */
-declare const has: <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

@@ -0,0 +1,29 @@
+// @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;