functionalscript 0.1.594 → 0.1.596

package/types/function/operator/module.f.d.mts

@@ -0,0 +1,75 @@
+declare namespace _default {
+    export { join };
+    export { addition };
+    export { increment };
+    export { strictEqual };
+    export { logicalNot };
+    export { min };
+    export { max };
+    export { stateScanToScan };
+    export { foldToScan };
+    export { reduceToScan };
+    export { counter };
+    export { concat };
+}
+export default _default;
+export type Binary<A, B, R> = (a: A) => (b: B) => R;
+export type Fold<I, O> = Binary<I, O, O>;
+export type Unary<T, R> = (value: T) => R;
+export type Equal<T> = Binary<T, T, boolean>;
+export type Scan<I, O> = (input: I) => readonly [O, Scan<I, O>];
+export type StateScan<I, S, O> = (prior: S) => (input: I) => readonly [O, S];
+export type Reduce<T> = Fold<T, T>;
+/**
+ * @template A
+ * @template B
+ * @template R
+ * @typedef {(a: A) => (b: B) => R} Binary
+ */
+/**
+ * @template I,O
+ * @typedef {Binary<I, O, O>} Fold
+ */
+/** @type {(separator: string) => Reduce<string>} */
+declare const join: (separator: string) => Reduce<string>;
+/** @type {Reduce<number>} */
+declare const addition: Reduce<number>;
+declare const increment: (b: number) => number;
+/**
+ * @template T
+ * @typedef {Binary<T, T, boolean>} Equal
+ */
+/** @type {<T>(a: T) => (b: T) => boolean} */
+declare const strictEqual: <T>(a: T) => (b: T) => boolean;
+/**
+ * @template T
+ * @template R
+ * @typedef {(value: T) => R} Unary
+ */
+/** @type {Unary<boolean, boolean>} */
+declare const logicalNot: Unary<boolean, boolean>;
+/** @type {Reduce<number>} */
+declare const min: Reduce<number>;
+/** @type {Reduce<number>} */
+declare const max: Reduce<number>;
+/**
+ * @template I,O
+ * @typedef {(input: I) => readonly[O, Scan<I,O>]} Scan
+ */
+/**
+ * @template I,S,O
+ * @typedef {(prior: S) => (input: I) => readonly[O, S]} StateScan
+ */
+/** @type {<I, S, O>(op: StateScan<I, S, O>) => (prior: S) => Scan<I, O>} */
+declare const stateScanToScan: <I, S, O>(op: StateScan<I, S, O>) => (prior: S) => Scan<I, O>;
+/** @type {<I, O>(fold: Fold<I, O>) => (prior: O) => Scan<I, O>} */
+declare const foldToScan: <I, O>(fold: Fold<I, O>) => (prior: O) => Scan<I, O>;
+/**
+ * @template T
+ * @typedef {Fold<T, T>} Reduce
+ */
+/** @type {<T>(fold: Reduce<T>) => Scan<T, T>} */
+declare const reduceToScan: <T>(fold: Reduce<T>) => Scan<T, T>;
+declare function counter(): (b: number) => number;
+/** @type {Reduce<string>} */
+declare const concat: Reduce<string>;

package/types/function/test.f.d.mts

@@ -0,0 +1,2 @@
+declare function _default(): void;
+export default _default;

package/types/list/module.f.d.mts

@@ -0,0 +1,117 @@
+declare namespace _default {
+    export let empty: null;
+    export { concat };
+    export { next };
+    export { iterable };
+    export { toArray };
+    export { flat };
+    export { map };
+    export { flatMap };
+    export { filter };
+    export { filterMap };
+    export { takeWhile };
+    export { take };
+    export { dropWhile };
+    export { drop };
+    export { first };
+    export { last };
+    export { find };
+    export { some };
+    export { every };
+    export { isEmpty };
+    export { includes };
+    export { countdown };
+    export { repeat };
+    export { cycle };
+    export { scan };
+    export { stateScan };
+    export { foldScan };
+    export { fold };
+    export { reduce };
+    export { length };
+    export { entries };
+    export { reverse };
+    export { zip };
+    export { equal };
+}
+export default _default;
+export type List<T> = NotLazy<T> | Thunk<T>;
+export type NotLazy<T> = Result<T> | Concat<T> | readonly T[];
+export type Empty = null;
+export type Result<T> = Empty | NonEmpty<T>;
+export type Thunk<T> = () => List<T>;
+export type NonEmpty<T> = {
+    readonly first: T;
+    readonly tail: List<T>;
+};
+export type Concat<T> = {
+    readonly head: List<T>;
+    readonly tail: List<T>;
+};
+export type Entry<T> = readonly [number, T];
+/** @type {<T>(head: List<T>) => (tail: List<T>) => List<T>} */
+declare const concat: <T>(head: List<T>) => (tail: List<T>) => List<T>;
+/** @type {<T>(list: List<T>) => Result<T>} */
+declare const next: <T>(list: List<T>) => Result<T>;
+/** @type {<T>(list: List<T>) => Iterable<T>} */
+declare const iterable: <T>(list: List<T>) => Iterable<T>;
+/** @type {<T>(list: List<T>) => readonly T[]} */
+declare const toArray: <T>(list: List<T>) => readonly T[];
+/** @type {<T>(list: List<List<T>>) => Thunk<T>} */
+declare const flat: <T>(list: List<List<T>>) => Thunk<T>;
+/** @type {<I, O>(f: (value: I) => O) => (input: List<I>) => Thunk<O>} */
+declare const map: <I, O>(f: (value: I) => O) => (input: List<I>) => Thunk<O>;
+/** @type {<I, O>(f: (value: I) => List<O>) => (input: List<I>) => Thunk<O>} */
+declare const flatMap: <I, O>(f: (value: I) => List<O>) => (input: List<I>) => Thunk<O>;
+/** @type {<T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>} */
+declare const filter: <T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>;
+/** @type {<I, O>(f: (value: I) => O|null) => (input: List<I>) => Thunk<O>} */
+declare const filterMap: <I, O>(f: (value: I) => O | null) => (input: List<I>) => Thunk<O>;
+/** @type {<T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>} */
+declare const takeWhile: <T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>;
+/** @type {(n: number) => <T>(input: List<T>) => Thunk<T>} */
+declare const take: (n: number) => <T>(input: List<T>) => Thunk<T>;
+/** @type {<T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>} */
+declare const dropWhile: <T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>;
+/** @type {(n: number) => <T>(input: List<T>) => Thunk<T>} */
+declare const drop: (n: number) => <T>(input: List<T>) => Thunk<T>;
+/** @type {<D>(def: D) => <T>(input: List<T>) => D|T} */
+declare const first: <D>(def: D) => <T>(input: List<T>) => D | T;
+/** @type {<D>(first: D) => <T>(tail: List<T>) => D|T} */
+declare const last: <D>(first: D) => <T>(tail: List<T>) => D | T;
+/** @type {<D>(def: D) => <T>(f: (value: T) => boolean) => (input: List<T>) => D|T} */
+declare const find: <D>(def: D) => <T>(f: (value: T) => boolean) => (input: List<T>) => D | T;
+/** @type {(input: List<boolean>) => boolean} */
+declare const some: (input: List<boolean>) => boolean;
+declare const every: import("../function/module.f.mjs").Func<List<boolean>, boolean>;
+/** @type {<T>(input: List<T>) => boolean} */
+declare const isEmpty: <T>(input: List<T>) => boolean;
+/** @type {<T>(value: T) => (sequence: List<T>) => boolean} */
+declare const includes: <T>(value: T) => (sequence: List<T>) => boolean;
+/** @type {(count: number) => Thunk<number>} */
+declare const countdown: (count: number) => Thunk<number>;
+/** @type {<T>(v: T) => (c: number) => Thunk<T>} */
+declare const repeat: <T>(v: T) => (c: number) => Thunk<T>;
+/** @type {<T>(list: List<T>) => List<T>} */
+declare const cycle: <T>(list: List<T>) => List<T>;
+/** @type {<I, O>(op: Operator.Scan<I, O>) => (input: List<I>) => Thunk<O>} */
+declare const scan: <I, O>(op: Operator.Scan<I, O>) => (input: List<I>) => Thunk<O>;
+/** @type {<I, S, O>(op: Operator.StateScan<I, S, O>) => (init: S) => (input: List<I>) => Thunk<O>} */
+declare const stateScan: <I, S, O>(op: Operator.StateScan<I, S, O>) => (init: S) => (input: List<I>) => Thunk<O>;
+/** @type {<I,O>(op: Operator.Fold<I, O>) => (init: O) => (input: List<I>) => Thunk<O>} */
+declare const foldScan: <I, O>(op: Operator.Fold<I, O>) => (init: O) => (input: List<I>) => Thunk<O>;
+/** @type {<I,O>(op: Operator.Fold<I, O>) => (init: O) => (input: List<I>) => O} */
+declare const fold: <I, O>(op: Operator.Fold<I, O>) => (init: O) => (input: List<I>) => O;
+/** @type {<T>(op: Operator.Reduce<T>) => <D>(def: D) => (input: List<T>) => D|T} */
+declare const reduce: <T>(op: Operator.Reduce<T>) => <D>(def: D) => (input: List<T>) => D | T;
+/** @type {<T>(input: List<T>) => number} */
+declare const length: <T>(input: List<T>) => number;
+/** @type {<T>(input: List<T>) => Thunk<Entry<T>>} */
+declare const entries: <T>(input: List<T>) => Thunk<Entry<T>>;
+/** @type {<T>(input: List<T>) => List<T>} */
+declare const reverse: <T>(input: List<T>) => List<T>;
+/** @type {<A>(a: List<A>) => <B>(b: List<B>) => Thunk<readonly[A, B]>} */
+declare const zip: <A>(a: List<A>) => <B>(b: List<B>) => Thunk<readonly [A, B]>;
+/** @type {<T>(e: Operator.Equal<T>) => (a: List<T>) => (b: List<T>) => boolean} */
+declare const equal: <T>(e: Operator.Equal<T>) => (a: List<T>) => (b: List<T>) => boolean;
+import * as Operator from '../function/operator/module.f.mjs';

package/types/list/test.f.d.mts

@@ -0,0 +1,38 @@
+declare namespace _default {
+    export { stringifyTest };
+    export { cycle };
+    export { countdown };
+    export { flat };
+    export { concat };
+    export { flatMap };
+    export { take };
+    export { find };
+    export { takeWhile };
+    export { dropWhile };
+    export { drop };
+    export { additionTests };
+    export { entries };
+    export { reverse };
+    export { zip };
+    export { logic };
+    export let strictEqual: (() => void)[];
+    export let isEmpty: (() => void)[];
+    export function length(): void;
+}
+export default _default;
+declare function stringifyTest(): void;
+declare function cycle(): void;
+declare function countdown(): void;
+declare function flat(): void;
+declare function concat(): void;
+declare function flatMap(): void;
+declare const take: (() => void)[];
+declare const find: (() => void)[];
+declare const takeWhile: (() => void)[];
+declare function dropWhile(): void;
+declare const drop: (() => void)[];
+declare const additionTests: (() => void)[];
+declare const entries: (() => void)[];
+declare const reverse: (() => void)[];
+declare const zip: (() => void)[];
+declare function logic(): (() => void)[];

package/types/map/module.f.d.mts

@@ -0,0 +1,30 @@
+declare namespace _default {
+    export let empty: null;
+    export { at };
+    export { setReduce };
+    export { setReplace };
+    export { entries };
+    export { fromEntries };
+    export { remove };
+}
+export default _default;
+export type Sign = Compare.Sign;
+export type Cmp<T> = Compare.Compare<T>;
+export type Entry<T> = readonly [string, T];
+export type Map<T> = btreeTypes.Tree<Entry<T>>;
+/** @type {(name: string) => <T>(map: Map<T>) => T|null} */
+declare const at: (name: string) => <T>(map: Map<T>) => T | null;
+/** @type {<T>(reduce: Operator.Reduce<T>) => (name: string) => (value: T) => (map: Map<T>) => Map<T>} */
+declare const setReduce: <T>(reduce: Operator.Reduce<T>) => (name: string) => (value: T) => (map: Map<T>) => Map<T>;
+/** @type {(name: string) => <T>(value: T) => (map: Map<T>) => Map<T>} */
+declare const setReplace: (name: string) => <T>(value: T) => (map: Map<T>) => Map<T>;
+/** @type {<T>(map: Map<T>) => List.List<Entry<T>>} */
+declare const entries: <T>(map: Map<T>) => List.List<Entry<T>>;
+/** @type {<T>(entries: List.List<Entry<T>>) => Map<T>} */
+declare const fromEntries: <T>(entries: List.List<Entry<T>>) => Map<T>;
+/** @type {(name: string) => <T>(map: Map<T>) => Map<T>} */
+declare const remove: (name: string) => <T>(map: Map<T>) => Map<T>;
+import * as Compare from '../function/compare/module.f.mjs';
+import * as btreeTypes from '../btree/types/module.f.mjs';
+import * as Operator from '../function/operator/module.f.mjs';
+import * as List from '../list/module.f.mjs';

package/types/map/test.f.d.mts

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

package/types/nibble_set/module.f.d.mts

@@ -0,0 +1,26 @@
+declare namespace _default {
+    export { empty };
+    export { universe };
+    export { has };
+    export { complement };
+    export { set };
+    export { unset };
+    export { setRange };
+}
+export default _default;
+export type NibbleSet = number;
+export type Nibble = number;
+/** @typedef {number} NibbleSet */
+/** @typedef {number} Nibble */
+declare const empty: 0;
+declare const universe: 65535;
+/** @type {(n: Nibble) => (s: NibbleSet) => boolean} */
+declare const has: (n: Nibble) => (s: NibbleSet) => boolean;
+/** @type {(n: NibbleSet) => NibbleSet} */
+declare const complement: (n: NibbleSet) => NibbleSet;
+/** @type {(n: Nibble) => (s: NibbleSet) => NibbleSet} */
+declare const set: (n: Nibble) => (s: NibbleSet) => NibbleSet;
+/** @type {(n: Nibble) => (s: NibbleSet) => NibbleSet} */
+declare const unset: (n: Nibble) => (s: NibbleSet) => NibbleSet;
+/** @type {(r: readonly[number, number]) => (s: NibbleSet) => NibbleSet} */
+declare const setRange: (r: readonly [number, number]) => (s: NibbleSet) => NibbleSet;

package/types/nibble_set/test.f.d.mts

@@ -0,0 +1,13 @@
+declare namespace _default {
+    function has(): void;
+    let set: (() => void)[];
+    function unset(): (() => void)[];
+    function setRange(): void;
+    function universe(): void;
+    namespace compliment {
+        export function empty(): void;
+        export function universe_1(): void;
+        export { universe_1 as universe };
+    }
+}
+export default _default;

package/types/nullable/module.f.d.mts

@@ -0,0 +1,14 @@
+declare namespace _default {
+    export { map };
+    export { match };
+}
+export default _default;
+export type Nullable<T> = T | null;
+/**
+ * @template T
+ * @typedef {T|null} Nullable
+ */
+/** @type {<T, R>(f: (value: T) => R) => (value: Nullable<T>) => Nullable<R>} */
+declare const map: <T, R>(f: (value: T) => R) => (value: Nullable<T>) => Nullable<R>;
+/** @type {<T, R>(f: (_: T) => R) => (none: () => R) => (_: Nullable<T>) => Nullable<R>} */
+declare const match: <T, R>(f: (_: T) => R) => (none: () => R) => (_: Nullable<T>) => Nullable<R>;

package/types/nullable/test.f.d.mts

@@ -0,0 +1,2 @@
+declare function _default(): void;
+export default _default;

package/types/number/module.f.d.mts

@@ -0,0 +1,13 @@
+declare namespace _default {
+    export { sum };
+    export { min };
+    export { max };
+    export { cmp };
+}
+export default _default;
+declare const sum: (input: import("../list/module.f.mjs").List<number>) => number;
+declare const min: (input: import("../list/module.f.mjs").List<number>) => number | null;
+declare const max: (input: import("../list/module.f.mjs").List<number>) => number | null;
+/** @type {(a: number) => (b: number) => Compare.Sign} */
+declare const cmp: (a: number) => (b: number) => Compare.Sign;
+import * as Compare from '../function/compare/module.f.mjs';

package/types/number/test.f.d.mts

@@ -0,0 +1,11 @@
+declare namespace _default {
+    function sum(): void;
+    namespace min {
+        function empty(): void;
+        function multi(): void;
+    }
+    function max(): void;
+    function cmp(): void;
+    function standard(): void;
+}
+export default _default;

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

@@ -0,0 +1,29 @@
+declare namespace _default {
+    export { at };
+    export { sort };
+    export { fromEntries };
+    export { fromMap };
+}
+export default _default;
+export type Map<T> = { readonly [k in string]: T; };
+export type Entry<T> = readonly [string, T];
+/**
+ * @template T
+ * @typedef {{
+ *  readonly [k in string]: T
+ * }} Map
+ */
+/**
+ * @template T
+ * @typedef {readonly[string, T]} Entry
+ */
+/** @type {(name: string) => <T>(object: Map<T>) => T|null} */
+declare const at: (name: string) => <T>(object: Map<T>) => T | null;
+/** @type {<T>(e: List.List<Entry<T>>) => List.List<Entry<T>>} */
+declare const sort: <T>(e: List.List<Entry<T>>) => List.List<Entry<T>>;
+/** @type {<T>(e: List.List<Entry<T>>) => Map<T>} */
+declare const fromEntries: <T>(e: List.List<Entry<T>>) => Map<T>;
+/** @type {<T>(m: Map.Map<T>) => Map<T>} */
+declare const fromMap: <T>(m: Map.Map<T>) => Map<T>;
+import * as List from '../list/module.f.mjs';
+import * as Map from '../map/module.f.mjs';

package/types/object/test.f.d.mts

@@ -0,0 +1,5 @@
+declare namespace _default {
+    function ctor(): void;
+    function property(): void;
+}
+export default _default;

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

@@ -0,0 +1,11 @@
+declare namespace _default {
+    export { contains };
+    export { one };
+}
+export default _default;
+export type Range = readonly [number, number];
+/** @typedef {readonly[number,number]} Range */
+/** @type {(range: Range) => (i: number) => boolean} */
+declare const contains: (range: Range) => (i: number) => boolean;
+/** @type {(i: number) => Range} */
+declare const one: (i: number) => Range;

package/types/range/test.f.d.mts

@@ -0,0 +1,2 @@
+declare function _default(): void;
+export default _default;

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

@@ -0,0 +1,25 @@
+declare namespace _default {
+    export { merge };
+    export { get };
+    export { fromRange };
+}
+export default _default;
+export type Entry<T> = [T, number];
+export type RangeMap<T> = SL.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>>;
+/** @type {<T>(op: Operators<T>) => RangeMerge<T>} */
+declare const merge: <T>(op: Operators<T>) => RangeMerge<T>;
+/** @type {<T>(def: T) => (value: number) => (rm: RangeMapArray<T>) => T} */
+declare const get: <T>(def: T) => (value: number) => (rm: RangeMapArray<T>) => T;
+/** @type {<T>(def: T) => (r: Range.Range) => (value: T) => RangeMapArray<T>} */
+declare const fromRange: <T>(def: T) => (r: Range.Range) => (value: T) => RangeMapArray<T>;
+import * as SL from '../sorted_list/module.f.mjs';
+import * as O from '../function/operator/module.f.mjs';
+import * as Option from '../nullable/module.f.mjs';
+import * as Range from '../range/module.f.mjs';

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

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

package/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/result/module.f.d.mts

@@ -0,0 +1,28 @@
+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
+ */
+/**
+ * @template E
+ * @typedef {readonly['error', E]} Error
+ */
+/**
+ * @template T
+ * @template E
+ * @typedef {Ok<T>|Error<E>} Result
+ */
+/** @type {<T>(value: T) => Ok<T>} */
+declare const ok: <T>(value: T) => Ok<T>;
+/** @type {<E>(e: E) => Error<E>} */
+declare 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;

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

@@ -0,0 +1,59 @@
+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
+ */
+/**
+ * @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>} */
+declare const genericMerge: <T, S>(reduce: MergeReduce<T, S>) => (state: S) => (a: List.List<T>) => (b: List.List<T>) => List.List<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';
+import * as compare from '../function/compare/module.f.mjs';
+import * as option from '../nullable/module.f.mjs';

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

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

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

@@ -0,0 +1,25 @@
+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
+ */
+/**
+ * @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>} */
+declare 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>;
+/** @type {<T>(cmp: Cmp<T>) => (value: T) => (set: SortedSet<T>) => boolean} */
+declare const has: <T>(cmp: Cmp<T>) => (value: T) => (set: SortedSet<T>) => boolean;
+import * as Compare from '../function/compare/module.f.mjs';

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

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

package/types/string/module.f.d.mts

@@ -0,0 +1,15 @@
+declare namespace _default {
+    export { join };
+    export { concat };
+    export { repeat };
+    export { cmp };
+}
+export default _default;
+declare const join: import("../function/module.f.mjs").Func<string, (input: List.List<string>) => string>;
+declare const concat: (input: List.List<string>) => string;
+/** @type {(n: string) => (v: number) => string} */
+declare const repeat: (n: string) => (v: number) => string;
+/** @type {(a: string) => (b: string) => Compare.Sign} */
+declare const cmp: (a: string) => (b: string) => Compare.Sign;
+import * as List from '../list/module.f.mjs';
+import * as Compare from '../function/compare/module.f.mjs';

package/types/string/test.f.d.mts

@@ -0,0 +1,15 @@
+declare namespace _default {
+    let join: {
+        0: () => void;
+        1: () => void;
+        3: () => void;
+    };
+    function concat(): void;
+    let repeatList: {
+        0: () => void;
+        5: () => void;
+    };
+    function repeat(): void;
+    function cmp(): void;
+}
+export default _default;

package/types/string_set/module.f.d.mts

@@ -0,0 +1,21 @@
+declare namespace _default {
+    export { empty };
+    export { contains };
+    export { set };
+    export { values };
+    export { fromValues };
+    export { remove };
+}
+export default _default;
+export type StringSet = BtreeTypes.Tree<string>;
+declare const empty: null;
+/** @typedef {BtreeTypes.Tree<string>} StringSet */
+/** @type {(value: string) => (set: StringSet) => boolean} */
+declare const contains: (value: string) => (set: StringSet) => boolean;
+/** @type {(value: string) => (s: StringSet) => StringSet} */
+declare const set: (value: string) => (s: StringSet) => StringSet;
+declare const values: <T>(tree: BtreeTypes.Tree<T>) => import("../list/module.f.mjs").List<T>;
+declare const fromValues: (input: import("../list/module.f.mjs").List<string>) => StringSet;
+/** @type {(value: string) => (s: StringSet) => StringSet} */
+declare const remove: (value: string) => (s: StringSet) => StringSet;
+import * as BtreeTypes from '../btree/types/module.f.mjs';

package/types/string_set/test.f.d.mts

@@ -0,0 +1,5 @@
+declare namespace _default {
+    function contains(): void;
+    function remove(): void;
+}
+export default _default;