@nlozgachev/pipelined 0.12.0 → 0.14.0

package/dist/utils.d.ts

@@ -0,0 +1,1285 @@
+import { a as Option, R as Result, T as Task } from './Task-BjAkkD6t.js';
+import { N as NonEmptyList } from './NonEmptyList-BlGFjor5.js';
+
+/**
+ * Functional array utilities that compose well with pipe.
+ * All functions are data-last and curried where applicable.
+ * Safe access functions return Option instead of throwing or returning undefined.
+ *
+ * @example
+ * ```ts
+ * pipe(
+ *   [1, 2, 3, 4, 5],
+ *   Arr.filter(n => n > 2),
+ *   Arr.map(n => n * 10),
+ *   Arr.head
+ * ); // Some(30)
+ * ```
+ */
+declare namespace Arr {
+    /**
+     * Returns the first element of an array, or None if the array is empty.
+     *
+     * @example
+     * ```ts
+     * Arr.head([1, 2, 3]); // Some(1)
+     * Arr.head([]); // None
+     * ```
+     */
+    const head: <A>(data: readonly A[]) => Option<A>;
+    /**
+     * Returns the last element of an array, or None if the array is empty.
+     *
+     * @example
+     * ```ts
+     * Arr.last([1, 2, 3]); // Some(3)
+     * Arr.last([]); // None
+     * ```
+     */
+    const last: <A>(data: readonly A[]) => Option<A>;
+    /**
+     * Returns all elements except the first, or None if the array is empty.
+     *
+     * @example
+     * ```ts
+     * Arr.tail([1, 2, 3]); // Some([2, 3])
+     * Arr.tail([]); // None
+     * ```
+     */
+    const tail: <A>(data: readonly A[]) => Option<readonly A[]>;
+    /**
+     * Returns all elements except the last, or None if the array is empty.
+     *
+     * @example
+     * ```ts
+     * Arr.init([1, 2, 3]); // Some([1, 2])
+     * Arr.init([]); // None
+     * ```
+     */
+    const init: <A>(data: readonly A[]) => Option<readonly A[]>;
+    /**
+     * Returns the first element matching the predicate, or None.
+     *
+     * @example
+     * ```ts
+     * pipe([1, 2, 3, 4], Arr.findFirst(n => n > 2)); // Some(3)
+     * ```
+     */
+    const findFirst: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => Option<A>;
+    /**
+     * Returns the last element matching the predicate, or None.
+     *
+     * @example
+     * ```ts
+     * pipe([1, 2, 3, 4], Arr.findLast(n => n > 2)); // Some(4)
+     * ```
+     */
+    const findLast: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => Option<A>;
+    /**
+     * Returns the index of the first element matching the predicate, or None.
+     *
+     * @example
+     * ```ts
+     * pipe([1, 2, 3, 4], Arr.findIndex(n => n > 2)); // Some(2)
+     * ```
+     */
+    const findIndex: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => Option<number>;
+    /**
+     * Transforms each element of an array.
+     *
+     * @example
+     * ```ts
+     * pipe([1, 2, 3], Arr.map(n => n * 2)); // [2, 4, 6]
+     * ```
+     */
+    const map: <A, B>(f: (a: A) => B) => (data: readonly A[]) => readonly B[];
+    /**
+     * Filters elements that satisfy the predicate.
+     *
+     * @example
+     * ```ts
+     * pipe([1, 2, 3, 4], Arr.filter(n => n % 2 === 0)); // [2, 4]
+     * ```
+     */
+    const filter: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => readonly A[];
+    /**
+     * Splits an array into two groups based on a predicate.
+     * First group contains elements that satisfy the predicate,
+     * second group contains the rest.
+     *
+     * @example
+     * ```ts
+     * pipe([1, 2, 3, 4], Arr.partition(n => n % 2 === 0)); // [[2, 4], [1, 3]]
+     * ```
+     */
+    const partition: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => readonly [readonly A[], readonly A[]];
+    /**
+     * Groups elements by a key function.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   ["apple", "avocado", "banana"],
+     *   Arr.groupBy(s => s[0])
+     * ); // { a: ["apple", "avocado"], b: ["banana"] }
+     * ```
+     */
+    const groupBy: <A>(f: (a: A) => string) => (data: readonly A[]) => Record<string, NonEmptyList<A>>;
+    /**
+     * Removes duplicate elements using strict equality.
+     *
+     * @example
+     * ```ts
+     * Arr.uniq([1, 2, 2, 3, 1]); // [1, 2, 3]
+     * ```
+     */
+    const uniq: <A>(data: readonly A[]) => readonly A[];
+    /**
+     * Removes duplicate elements by comparing the result of a key function.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   [{id: 1, name: "a"}, {id: 1, name: "b"}, {id: 2, name: "c"}],
+     *   Arr.uniqBy(x => x.id)
+     * ); // [{id: 1, name: "a"}, {id: 2, name: "c"}]
+     * ```
+     */
+    const uniqBy: <A, B>(f: (a: A) => B) => (data: readonly A[]) => readonly A[];
+    /**
+     * Sorts an array using a comparison function. Returns a new array.
+     *
+     * @example
+     * ```ts
+     * pipe([3, 1, 2], Arr.sortBy((a, b) => a - b)); // [1, 2, 3]
+     * ```
+     */
+    const sortBy: <A>(compare: (a: A, b: A) => number) => (data: readonly A[]) => readonly A[];
+    /**
+     * Pairs up elements from two arrays. Stops at the shorter array.
+     *
+     * @example
+     * ```ts
+     * pipe([1, 2, 3], Arr.zip(["a", "b"])); // [[1, "a"], [2, "b"]]
+     * ```
+     */
+    const zip: <B>(other: readonly B[]) => <A>(data: readonly A[]) => readonly (readonly [A, B])[];
+    /**
+     * Combines elements from two arrays using a function. Stops at the shorter array.
+     *
+     * @example
+     * ```ts
+     * pipe([1, 2], Arr.zipWith((a, b) => a + b, ["a", "b"])); // ["1a", "2b"]
+     * ```
+     */
+    const zipWith: <A, B, C>(f: (a: A, b: B) => C) => (other: readonly B[]) => (data: readonly A[]) => readonly C[];
+    /**
+     * Inserts a separator between every element.
+     *
+     * @example
+     * ```ts
+     * pipe([1, 2, 3], Arr.intersperse(0)); // [1, 0, 2, 0, 3]
+     * ```
+     */
+    const intersperse: <A>(sep: A) => (data: readonly A[]) => readonly A[];
+    /**
+     * Splits an array into chunks of the given size.
+     *
+     * @example
+     * ```ts
+     * pipe([1, 2, 3, 4, 5], Arr.chunksOf(2)); // [[1, 2], [3, 4], [5]]
+     * ```
+     */
+    const chunksOf: (n: number) => <A>(data: readonly A[]) => readonly (readonly A[])[];
+    /**
+     * Flattens a nested array by one level.
+     *
+     * @example
+     * ```ts
+     * Arr.flatten([[1, 2], [3], [4, 5]]); // [1, 2, 3, 4, 5]
+     * ```
+     */
+    const flatten: <A>(data: readonly (readonly A[])[]) => readonly A[];
+    /**
+     * Maps each element to an array and flattens the result.
+     *
+     * @example
+     * ```ts
+     * pipe([1, 2, 3], Arr.flatMap(n => [n, n * 10])); // [1, 10, 2, 20, 3, 30]
+     * ```
+     */
+    const flatMap: <A, B>(f: (a: A) => readonly B[]) => (data: readonly A[]) => readonly B[];
+    /**
+     * Reduces an array from the left.
+     *
+     * @example
+     * ```ts
+     * pipe([1, 2, 3], Arr.reduce(0, (acc, n) => acc + n)); // 6
+     * ```
+     */
+    const reduce: <A, B>(initial: B, f: (acc: B, a: A) => B) => (data: readonly A[]) => B;
+    /**
+     * Maps each element to an Option and collects the results.
+     * Returns None if any mapping returns None.
+     *
+     * @example
+     * ```ts
+     * const parseNum = (s: string): Option<number> => {
+     *   const n = Number(s);
+     *   return isNaN(n) ? Option.none() : Option.some(n);
+     * };
+     *
+     * pipe(["1", "2", "3"], Arr.traverse(parseNum)); // Some([1, 2, 3])
+     * pipe(["1", "x", "3"], Arr.traverse(parseNum)); // None
+     * ```
+     */
+    const traverse: <A, B>(f: (a: A) => Option<B>) => (data: readonly A[]) => Option<readonly B[]>;
+    /**
+     * Maps each element to a Result and collects the results.
+     * Returns the first Err if any mapping fails.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   [1, 2, 3],
+     *   Arr.traverseResult(n => n > 0 ? Result.ok(n) : Result.err("negative"))
+     * ); // Ok([1, 2, 3])
+     * ```
+     */
+    const traverseResult: <E, A, B>(f: (a: A) => Result<E, B>) => (data: readonly A[]) => Result<E, readonly B[]>;
+    /**
+     * Maps each element to a Task and runs all in parallel.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   [1, 2, 3],
+     *   Arr.traverseTask(n => Task.resolve(n * 2))
+     * )(); // Promise<[2, 4, 6]>
+     * ```
+     */
+    const traverseTask: <A, B>(f: (a: A) => Task<B>) => (data: readonly A[]) => Task<readonly B[]>;
+    /**
+     * Collects an array of Options into an Option of array.
+     * Returns None if any element is None.
+     *
+     * @example
+     * ```ts
+     * Arr.sequence([Option.some(1), Option.some(2)]); // Some([1, 2])
+     * Arr.sequence([Option.some(1), Option.none()]); // None
+     * ```
+     */
+    const sequence: <A>(data: readonly Option<A>[]) => Option<readonly A[]>;
+    /**
+     * Collects an array of Results into a Result of array.
+     * Returns the first Err if any element is Err.
+     */
+    const sequenceResult: <E, A>(data: readonly Result<E, A>[]) => Result<E, readonly A[]>;
+    /**
+     * Collects an array of Tasks into a Task of array. Runs in parallel.
+     */
+    const sequenceTask: <A>(data: readonly Task<A>[]) => Task<readonly A[]>;
+    /**
+     * Maps each element to a TaskResult and runs them sequentially.
+     * Returns the first Err encountered, or Ok of all results if all succeed.
+     *
+     * @example
+     * ```ts
+     * const validate = (n: number): TaskResult<string, number> =>
+     *   n > 0 ? TaskResult.ok(n) : TaskResult.err("non-positive");
+     *
+     * pipe(
+     *   [1, 2, 3],
+     *   Arr.traverseTaskResult(validate)
+     * )(); // Deferred<Ok([1, 2, 3])>
+     *
+     * pipe(
+     *   [1, -1, 3],
+     *   Arr.traverseTaskResult(validate)
+     * )(); // Deferred<Err("non-positive")>
+     * ```
+     */
+    const traverseTaskResult: <E, A, B>(f: (a: A) => Task<Result<E, B>>) => (data: readonly A[]) => Task<Result<E, readonly B[]>>;
+    /**
+     * Collects an array of TaskResults into a TaskResult of array.
+     * Returns the first Err if any element is Err, runs sequentially.
+     */
+    const sequenceTaskResult: <E, A>(data: readonly Task<Result<E, A>>[]) => Task<Result<E, readonly A[]>>;
+    /**
+     * Returns true if the array is non-empty (type guard).
+     */
+    const isNonEmpty: <A>(data: readonly A[]) => data is NonEmptyList<A>;
+    /**
+     * Returns the length of an array.
+     */
+    const size: <A>(data: readonly A[]) => number;
+    /**
+     * Returns true if any element satisfies the predicate.
+     *
+     * @example
+     * ```ts
+     * pipe([1, 2, 3], Arr.some(n => n > 2)); // true
+     * ```
+     */
+    const some: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => boolean;
+    /**
+     * Returns true if all elements satisfy the predicate.
+     *
+     * @example
+     * ```ts
+     * pipe([1, 2, 3], Arr.every(n => n > 0)); // true
+     * ```
+     */
+    const every: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => boolean;
+    /**
+     * Reverses an array. Returns a new array.
+     *
+     * @example
+     * ```ts
+     * Arr.reverse([1, 2, 3]); // [3, 2, 1]
+     * ```
+     */
+    const reverse: <A>(data: readonly A[]) => readonly A[];
+    /**
+     * Takes the first n elements from an array.
+     *
+     * @example
+     * ```ts
+     * pipe([1, 2, 3, 4], Arr.take(2)); // [1, 2]
+     * ```
+     */
+    const take: (n: number) => <A>(data: readonly A[]) => readonly A[];
+    /**
+     * Drops the first n elements from an array.
+     *
+     * @example
+     * ```ts
+     * pipe([1, 2, 3, 4], Arr.drop(2)); // [3, 4]
+     * ```
+     */
+    const drop: (n: number) => <A>(data: readonly A[]) => readonly A[];
+    /**
+     * Takes elements from the start while the predicate holds.
+     *
+     * @example
+     * ```ts
+     * pipe([1, 2, 3, 1], Arr.takeWhile(n => n < 3)); // [1, 2]
+     * ```
+     */
+    const takeWhile: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => readonly A[];
+    /**
+     * Drops elements from the start while the predicate holds.
+     *
+     * @example
+     * ```ts
+     * pipe([1, 2, 3, 1], Arr.dropWhile(n => n < 3)); // [3, 1]
+     * ```
+     */
+    const dropWhile: <A>(predicate: (a: A) => boolean) => (data: readonly A[]) => readonly A[];
+    /**
+     * Like `reduce`, but returns every intermediate accumulator as an array.
+     * The initial value is not included — the output has the same length as the input.
+     *
+     * @example
+     * ```ts
+     * pipe([1, 2, 3], Arr.scan(0, (acc, n) => acc + n)); // [1, 3, 6]
+     * ```
+     */
+    const scan: <A, B>(initial: B, f: (acc: B, a: A) => B) => (data: readonly A[]) => readonly B[];
+    /**
+     * Splits an array at an index into a `[before, after]` tuple.
+     * Negative indices clamp to 0; indices beyond the array length clamp to the end.
+     *
+     * @example
+     * ```ts
+     * pipe([1, 2, 3, 4], Arr.splitAt(2)); // [[1, 2], [3, 4]]
+     * pipe([1, 2, 3], Arr.splitAt(0));    // [[], [1, 2, 3]]
+     * pipe([1, 2, 3], Arr.splitAt(10));   // [[1, 2, 3], []]
+     * ```
+     */
+    const splitAt: (index: number) => <A>(data: readonly A[]) => readonly [readonly A[], readonly A[]];
+}
+
+/**
+ * Functional utilities for key-value dictionaries (`ReadonlyMap<K, V>`). All functions are pure
+ * and data-last — they compose naturally with `pipe`.
+ *
+ * Unlike plain objects (`Rec`), dictionaries support any key type, preserve insertion order, and
+ * make membership checks explicit via `lookup` returning `Option`.
+ *
+ * @example
+ * ```ts
+ * import { Dict } from "@nlozgachev/pipelined/utils";
+ * import { pipe } from "@nlozgachev/pipelined/composition";
+ *
+ * const scores = pipe(
+ *   Dict.fromEntries([["alice", 10], ["bob", 8], ["carol", 10]] as const),
+ *   Dict.filter(n => n >= 10),
+ *   Dict.map(n => `${n} points`),
+ * );
+ * // ReadonlyMap { "alice" => "10 points", "carol" => "10 points" }
+ * ```
+ */
+declare namespace Dict {
+    /**
+     * Creates an empty dictionary.
+     *
+     * @example
+     * ```ts
+     * Dict.empty<string, number>(); // ReadonlyMap {}
+     * ```
+     */
+    const empty: <K, V>() => ReadonlyMap<K, V>;
+    /**
+     * Creates a dictionary with a single entry.
+     *
+     * @example
+     * ```ts
+     * Dict.singleton("name", "Alice"); // ReadonlyMap { "name" => "Alice" }
+     * ```
+     */
+    const singleton: <K, V>(key: K, value: V) => ReadonlyMap<K, V>;
+    /**
+     * Creates a dictionary from an array of key-value pairs.
+     *
+     * @example
+     * ```ts
+     * Dict.fromEntries([["a", 1], ["b", 2]]); // ReadonlyMap { "a" => 1, "b" => 2 }
+     * ```
+     */
+    const fromEntries: <K, V>(entries: readonly (readonly [K, V])[]) => ReadonlyMap<K, V>;
+    /**
+     * Creates a dictionary from a plain object. Keys are always strings.
+     *
+     * @example
+     * ```ts
+     * Dict.fromRecord({ a: 1, b: 2 }); // ReadonlyMap { "a" => 1, "b" => 2 }
+     * ```
+     */
+    const fromRecord: <V>(rec: Readonly<Record<string, V>>) => ReadonlyMap<string, V>;
+    /**
+     * Groups elements of an array into a dictionary keyed by the result of `keyFn`. Each key maps
+     * to the array of elements that produced it, in insertion order. Uses the native `Map.groupBy`
+     * when available, falling back to a manual loop in older environments.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   [{ name: "alice", role: "admin" }, { name: "bob", role: "viewer" }, { name: "carol", role: "admin" }],
+     *   Dict.groupBy(user => user.role),
+     * );
+     * // ReadonlyMap { "admin" => [alice, carol], "viewer" => [bob] }
+     * ```
+     */
+    const groupBy: <K, A>(keyFn: (a: A) => K) => (items: readonly A[]) => ReadonlyMap<K, readonly A[]>;
+    /**
+     * Returns `true` if the dictionary contains the given key.
+     *
+     * @example
+     * ```ts
+     * pipe(Dict.fromEntries([["a", 1]]), Dict.has("a")); // true
+     * pipe(Dict.fromEntries([["a", 1]]), Dict.has("b")); // false
+     * ```
+     */
+    const has: <K>(key: K) => <V>(m: ReadonlyMap<K, V>) => boolean;
+    /**
+     * Looks up a value by key, returning `Some(value)` if found and `None` if not.
+     *
+     * @example
+     * ```ts
+     * pipe(Dict.fromEntries([["a", 1]]), Dict.lookup("a")); // Some(1)
+     * pipe(Dict.fromEntries([["a", 1]]), Dict.lookup("b")); // None
+     * ```
+     */
+    const lookup: <K>(key: K) => <V>(m: ReadonlyMap<K, V>) => Option<V>;
+    /**
+     * Returns the number of entries in the dictionary.
+     *
+     * @example
+     * ```ts
+     * Dict.size(Dict.fromEntries([["a", 1], ["b", 2]])); // 2
+     * ```
+     */
+    const size: <K, V>(m: ReadonlyMap<K, V>) => number;
+    /**
+     * Returns `true` if the dictionary has no entries.
+     *
+     * @example
+     * ```ts
+     * Dict.isEmpty(Dict.empty()); // true
+     * ```
+     */
+    const isEmpty: <K, V>(m: ReadonlyMap<K, V>) => boolean;
+    /**
+     * Returns all keys as a readonly array, in insertion order.
+     *
+     * @example
+     * ```ts
+     * Dict.keys(Dict.fromEntries([["a", 1], ["b", 2]])); // ["a", "b"]
+     * ```
+     */
+    const keys: <K, V>(m: ReadonlyMap<K, V>) => readonly K[];
+    /**
+     * Returns all values as a readonly array, in insertion order.
+     *
+     * @example
+     * ```ts
+     * Dict.values(Dict.fromEntries([["a", 1], ["b", 2]])); // [1, 2]
+     * ```
+     */
+    const values: <K, V>(m: ReadonlyMap<K, V>) => readonly V[];
+    /**
+     * Returns all key-value pairs as a readonly array of tuples, in insertion order.
+     *
+     * @example
+     * ```ts
+     * Dict.entries(Dict.fromEntries([["a", 1], ["b", 2]])); // [["a", 1], ["b", 2]]
+     * ```
+     */
+    const entries: <K, V>(m: ReadonlyMap<K, V>) => readonly (readonly [K, V])[];
+    /**
+     * Returns a new dictionary with the given key set to the given value.
+     * If the key already exists, its value is replaced.
+     *
+     * @example
+     * ```ts
+     * pipe(Dict.fromEntries([["a", 1]]), Dict.insert("b", 2));
+     * // ReadonlyMap { "a" => 1, "b" => 2 }
+     * ```
+     */
+    const insert: <K, V>(key: K, value: V) => (m: ReadonlyMap<K, V>) => ReadonlyMap<K, V>;
+    /**
+     * Returns a new dictionary with the given key removed.
+     * If the key does not exist, the dictionary is returned unchanged.
+     *
+     * @example
+     * ```ts
+     * pipe(Dict.fromEntries([["a", 1], ["b", 2]]), Dict.remove("a"));
+     * // ReadonlyMap { "b" => 2 }
+     * ```
+     */
+    const remove: <K, V>(key: K) => (m: ReadonlyMap<K, V>) => ReadonlyMap<K, V>;
+    /**
+     * Returns a new dictionary with the value at `key` set by `f`. If the key does not exist,
+     * `f` receives `None`. If the key exists, `f` receives `Some(currentValue)`.
+     *
+     * Useful for incrementing counters, initialising defaults, or conditional updates.
+     *
+     * @example
+     * ```ts
+     * import { Option } from "@nlozgachev/pipelined/core";
+     *
+     * const increment = (opt: Option<number>) => Option.getOrElse(() => 0)(opt) + 1;
+     * pipe(Dict.fromEntries([["views", 5]]), Dict.upsert("views", increment)); // { views: 6 }
+     * pipe(Dict.fromEntries([["views", 5]]), Dict.upsert("likes", increment)); // { views: 5, likes: 1 }
+     * ```
+     */
+    const upsert: <K, V>(key: K, f: (existing: Option<V>) => V) => (m: ReadonlyMap<K, V>) => ReadonlyMap<K, V>;
+    /**
+     * Transforms each value in the dictionary.
+     *
+     * @example
+     * ```ts
+     * pipe(Dict.fromEntries([["a", 1], ["b", 2]]), Dict.map(n => n * 2));
+     * // ReadonlyMap { "a" => 2, "b" => 4 }
+     * ```
+     */
+    const map: <A, B>(f: (a: A) => B) => <K>(m: ReadonlyMap<K, A>) => ReadonlyMap<K, B>;
+    /**
+     * Transforms each value in the dictionary, also receiving the key.
+     *
+     * @example
+     * ```ts
+     * pipe(Dict.fromEntries([["a", 1], ["b", 2]]), Dict.mapWithKey((k, v) => `${k}:${v}`));
+     * // ReadonlyMap { "a" => "a:1", "b" => "b:2" }
+     * ```
+     */
+    const mapWithKey: <K, A, B>(f: (key: K, a: A) => B) => (m: ReadonlyMap<K, A>) => ReadonlyMap<K, B>;
+    /**
+     * Returns a new dictionary containing only the entries for which the predicate returns `true`.
+     *
+     * @example
+     * ```ts
+     * pipe(Dict.fromEntries([["a", 1], ["b", 3], ["c", 0]]), Dict.filter(n => n > 0));
+     * // ReadonlyMap { "a" => 1, "b" => 3 }
+     * ```
+     */
+    const filter: <A>(predicate: (a: A) => boolean) => <K>(m: ReadonlyMap<K, A>) => ReadonlyMap<K, A>;
+    /**
+     * Returns a new dictionary containing only the entries for which the predicate returns `true`.
+     * The predicate also receives the key.
+     *
+     * @example
+     * ```ts
+     * pipe(Dict.fromEntries([["a", 1], ["b", 2]]), Dict.filterWithKey((k, v) => k !== "a" && v > 0));
+     * // ReadonlyMap { "b" => 2 }
+     * ```
+     */
+    const filterWithKey: <K, A>(predicate: (key: K, a: A) => boolean) => (m: ReadonlyMap<K, A>) => ReadonlyMap<K, A>;
+    /**
+     * Removes all `None` values from a `ReadonlyMap<K, Option<A>>`, returning a plain
+     * `ReadonlyMap<K, A>`. Useful when building dictionaries from fallible lookups.
+     *
+     * @example
+     * ```ts
+     * import { Option } from "@nlozgachev/pipelined/core";
+     *
+     * Dict.compact(Dict.fromEntries([
+     *   ["a", Option.some(1)],
+     *   ["b", Option.none()],
+     *   ["c", Option.some(3)],
+     * ]));
+     * // ReadonlyMap { "a" => 1, "c" => 3 }
+     * ```
+     */
+    const compact: <K, A>(m: ReadonlyMap<K, Option<A>>) => ReadonlyMap<K, A>;
+    /**
+     * Merges two dictionaries. When both contain the same key, the value from `other` takes
+     * precedence.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Dict.fromEntries([["a", 1], ["b", 2]]),
+     *   Dict.union(Dict.fromEntries([["b", 3], ["c", 4]])),
+     * );
+     * // ReadonlyMap { "a" => 1, "b" => 3, "c" => 4 }
+     * ```
+     */
+    const union: <K, V>(other: ReadonlyMap<K, V>) => (m: ReadonlyMap<K, V>) => ReadonlyMap<K, V>;
+    /**
+     * Returns a new dictionary containing only the entries whose keys appear in both dictionaries.
+     * Values are taken from the left (base) dictionary.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Dict.fromEntries([["a", 1], ["b", 2], ["c", 3]]),
+     *   Dict.intersection(Dict.fromEntries([["b", 99], ["c", 0]])),
+     * );
+     * // ReadonlyMap { "b" => 2, "c" => 3 }
+     * ```
+     */
+    const intersection: <K, V>(other: ReadonlyMap<K, unknown>) => (m: ReadonlyMap<K, V>) => ReadonlyMap<K, V>;
+    /**
+     * Returns a new dictionary containing only the entries whose keys do not appear in `other`.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Dict.fromEntries([["a", 1], ["b", 2], ["c", 3]]),
+     *   Dict.difference(Dict.fromEntries([["b", 0]])),
+     * );
+     * // ReadonlyMap { "a" => 1, "c" => 3 }
+     * ```
+     */
+    const difference: <K, V>(other: ReadonlyMap<K, unknown>) => (m: ReadonlyMap<K, V>) => ReadonlyMap<K, V>;
+    /**
+     * Folds the dictionary into a single value by applying `f` to each value in insertion order.
+     * When you also need the key, use `reduceWithKey`.
+     *
+     * @example
+     * ```ts
+     * Dict.reduce(0, (acc, value) => acc + value)(
+     *   Dict.fromEntries([["a", 1], ["b", 2], ["c", 3]])
+     * ); // 6
+     * ```
+     */
+    const reduce: <A, B>(init: B, f: (acc: B, value: A) => B) => <K>(m: ReadonlyMap<K, A>) => B;
+    /**
+     * Folds the dictionary into a single value by applying `f` to each key-value pair in insertion
+     * order.
+     *
+     * @example
+     * ```ts
+     * Dict.reduceWithKey("", (acc, value, key) => acc + key + ":" + value + " ")(
+     *   Dict.fromEntries([["a", 1], ["b", 2]])
+     * ); // "a:1 b:2 "
+     * ```
+     */
+    const reduceWithKey: <K, A, B>(init: B, f: (acc: B, value: A, key: K) => B) => (m: ReadonlyMap<K, A>) => B;
+    /**
+     * Converts a `ReadonlyMap<string, V>` to a plain object. Only meaningful when keys are strings.
+     *
+     * @example
+     * ```ts
+     * Dict.toRecord(Dict.fromEntries([["a", 1], ["b", 2]])); // { a: 1, b: 2 }
+     * ```
+     */
+    const toRecord: <V>(m: ReadonlyMap<string, V>) => Readonly<Record<string, V>>;
+}
+
+/**
+ * Number utilities for common operations. All transformation functions are data-last
+ * and curried so they compose naturally with `pipe` and `Arr.map`.
+ *
+ * @example
+ * ```ts
+ * import { Num } from "@nlozgachev/pipelined/utils";
+ * import { pipe } from "@nlozgachev/pipelined/composition";
+ *
+ * pipe(
+ *   Num.range(1, 6),
+ *   Arr.map(Num.multiply(2)),
+ *   Arr.filter(Num.between(4, 8))
+ * ); // [4, 6, 8]
+ * ```
+ */
+declare namespace Num {
+    /**
+     * Generates an array of numbers from `from` to `to` (both inclusive),
+     * stepping by `step` (default `1`). If `step` is negative or zero, or `from > to`,
+     * returns an empty array. When `step` does not land exactly on `to`, the last value
+     * is the largest reachable value that does not exceed `to`.
+     *
+     * @example
+     * ```ts
+     * Num.range(0, 5);       // [0, 1, 2, 3, 4, 5]
+     * Num.range(0, 10, 2);   // [0, 2, 4, 6, 8, 10]
+     * Num.range(0, 9, 2);    // [0, 2, 4, 6, 8]
+     * Num.range(5, 0);       // []
+     * Num.range(3, 3);       // [3]
+     * ```
+     */
+    const range: (from: number, to: number, step?: number) => readonly number[];
+    /**
+     * Clamps a number between `min` and `max` (both inclusive).
+     *
+     * @example
+     * ```ts
+     * pipe(150, Num.clamp(0, 100)); // 100
+     * pipe(-5, Num.clamp(0, 100));  // 0
+     * pipe(42, Num.clamp(0, 100));  // 42
+     * ```
+     */
+    const clamp: (min: number, max: number) => (n: number) => number;
+    /**
+     * Returns `true` when the number is between `min` and `max` (both inclusive).
+     *
+     * @example
+     * ```ts
+     * pipe(5, Num.between(1, 10));  // true
+     * pipe(0, Num.between(1, 10));  // false
+     * pipe(10, Num.between(1, 10)); // true
+     * ```
+     */
+    const between: (min: number, max: number) => (n: number) => boolean;
+    /**
+     * Parses a string as a number. Returns `None` when the result is `NaN`.
+     *
+     * @example
+     * ```ts
+     * Num.parse("42");   // Some(42)
+     * Num.parse("3.14"); // Some(3.14)
+     * Num.parse("abc");  // None
+     * Num.parse("");     // None
+     * ```
+     */
+    const parse: (s: string) => Option<number>;
+    /**
+     * Adds `b` to a number. Data-last: use in `pipe` or `Arr.map`.
+     *
+     * @example
+     * ```ts
+     * pipe(5, Num.add(3));                   // 8
+     * pipe([1, 2, 3], Arr.map(Num.add(10))); // [11, 12, 13]
+     * ```
+     */
+    const add: (b: number) => (a: number) => number;
+    /**
+     * Subtracts `b` from a number. Data-last: `subtract(b)(a)` = `a - b`.
+     *
+     * @example
+     * ```ts
+     * pipe(10, Num.subtract(3));                  // 7
+     * pipe([5, 10, 15], Arr.map(Num.subtract(2))); // [3, 8, 13]
+     * ```
+     */
+    const subtract: (b: number) => (a: number) => number;
+    /**
+     * Multiplies a number by `b`. Data-last: use in `pipe` or `Arr.map`.
+     *
+     * @example
+     * ```ts
+     * pipe(6, Num.multiply(7));                    // 42
+     * pipe([1, 2, 3], Arr.map(Num.multiply(100))); // [100, 200, 300]
+     * ```
+     */
+    const multiply: (b: number) => (a: number) => number;
+    /**
+     * Divides a number by `b`. Data-last: `divide(b)(a)` = `a / b`.
+     *
+     * @example
+     * ```ts
+     * pipe(20, Num.divide(4));                      // 5
+     * pipe([10, 20, 30], Arr.map(Num.divide(10)));  // [1, 2, 3]
+     * ```
+     */
+    const divide: (b: number) => (a: number) => number;
+}
+
+/**
+ * Functional record/object utilities that compose well with pipe.
+ * All functions are data-last and curried where applicable.
+ *
+ * @example
+ * ```ts
+ * pipe(
+ *   { a: 1, b: 2, c: 3 },
+ *   Rec.filter(n => n > 1),
+ *   Rec.map(n => n * 10)
+ * ); // { b: 20, c: 30 }
+ * ```
+ */
+declare namespace Rec {
+    /**
+     * Transforms each value in a record.
+     *
+     * @example
+     * ```ts
+     * pipe({ a: 1, b: 2 }, Rec.map(n => n * 2)); // { a: 2, b: 4 }
+     * ```
+     */
+    const map: <A, B>(f: (a: A) => B) => (data: Readonly<Record<string, A>>) => Readonly<Record<string, B>>;
+    /**
+     * Transforms each value in a record, also receiving the key.
+     *
+     * @example
+     * ```ts
+     * pipe({ a: 1, b: 2 }, Rec.mapWithKey((k, v) => `${k}:${v}`));
+     * // { a: "a:1", b: "b:2" }
+     * ```
+     */
+    const mapWithKey: <A, B>(f: (key: string, a: A) => B) => (data: Readonly<Record<string, A>>) => Readonly<Record<string, B>>;
+    /**
+     * Filters values in a record by a predicate.
+     *
+     * @example
+     * ```ts
+     * pipe({ a: 1, b: 2, c: 3 }, Rec.filter(n => n > 1)); // { b: 2, c: 3 }
+     * ```
+     */
+    const filter: <A>(predicate: (a: A) => boolean) => (data: Readonly<Record<string, A>>) => Readonly<Record<string, A>>;
+    /**
+     * Filters values in a record by a predicate that also receives the key.
+     *
+     * @example
+     * ```ts
+     * pipe({ a: 1, b: 2 }, Rec.filterWithKey((k, v) => k !== "a" && v > 0));
+     * // { b: 2 }
+     * ```
+     */
+    const filterWithKey: <A>(predicate: (key: string, a: A) => boolean) => (data: Readonly<Record<string, A>>) => Readonly<Record<string, A>>;
+    /**
+     * Looks up a value by key, returning Option.
+     *
+     * @example
+     * ```ts
+     * pipe({ a: 1, b: 2 }, Rec.lookup("a")); // Some(1)
+     * pipe({ a: 1, b: 2 }, Rec.lookup("c")); // None
+     * ```
+     */
+    const lookup: (key: string) => <A>(data: Readonly<Record<string, A>>) => Option<A>;
+    /**
+     * Returns all keys of a record.
+     */
+    const keys: <A>(data: Readonly<Record<string, A>>) => readonly string[];
+    /**
+     * Returns all values of a record.
+     */
+    const values: <A>(data: Readonly<Record<string, A>>) => readonly A[];
+    /**
+     * Returns all key-value pairs of a record.
+     */
+    const entries: <A>(data: Readonly<Record<string, A>>) => readonly (readonly [string, A])[];
+    /**
+     * Creates a record from key-value pairs.
+     *
+     * @example
+     * ```ts
+     * Rec.fromEntries([["a", 1], ["b", 2]]); // { a: 1, b: 2 }
+     * ```
+     */
+    const fromEntries: <A>(data: readonly (readonly [string, A])[]) => Readonly<Record<string, A>>;
+    /**
+     * Groups elements of an array into a record keyed by the result of `keyFn`. Each key maps to
+     * the array of elements that produced it, in insertion order.
+     *
+     * Unlike `Dict.groupBy`, keys are always strings. Use `Dict.groupBy` when you need non-string
+     * keys or want to avoid the plain-object prototype chain.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   ["apple", "avocado", "banana", "blueberry"],
+     *   Rec.groupBy(s => s[0]),
+     * ); // { a: ["apple", "avocado"], b: ["banana", "blueberry"] }
+     * ```
+     */
+    const groupBy: <A>(keyFn: (a: A) => string) => (items: readonly A[]) => Readonly<Record<string, readonly A[]>>;
+    /**
+     * Picks specific keys from a record.
+     *
+     * @example
+     * ```ts
+     * pipe({ a: 1, b: 2, c: 3 }, Rec.pick("a", "c")); // { a: 1, c: 3 }
+     * ```
+     */
+    const pick: <K extends string>(...pickedKeys: K[]) => <A extends Record<K, unknown>>(data: A) => Pick<A, K>;
+    /**
+     * Omits specific keys from a record.
+     *
+     * @example
+     * ```ts
+     * pipe({ a: 1, b: 2, c: 3 }, Rec.omit("b")); // { a: 1, c: 3 }
+     * ```
+     */
+    const omit: <K extends string>(...omittedKeys: K[]) => <A extends Record<K, unknown>>(data: A) => Omit<A, K>;
+    /**
+     * Merges two records. Values from the second record take precedence.
+     *
+     * @example
+     * ```ts
+     * pipe({ a: 1, b: 2 }, Rec.merge({ b: 3, c: 4 })); // { a: 1, b: 3, c: 4 }
+     * ```
+     */
+    const merge: <A>(other: Readonly<Record<string, A>>) => (data: Readonly<Record<string, A>>) => Readonly<Record<string, A>>;
+    /**
+     * Returns true if the record has no keys.
+     */
+    const isEmpty: <A>(data: Readonly<Record<string, A>>) => boolean;
+    /**
+     * Returns the number of keys in a record.
+     */
+    const size: <A>(data: Readonly<Record<string, A>>) => number;
+    /**
+     * Transforms each key while preserving values.
+     * If two keys map to the same new key, the last one wins.
+     *
+     * @example
+     * ```ts
+     * pipe({ firstName: "Alice", lastName: "Smith" }, Rec.mapKeys(k => k.toUpperCase()));
+     * // { FIRSTNAME: "Alice", LASTNAME: "Smith" }
+     * ```
+     */
+    const mapKeys: (f: (key: string) => string) => <A>(data: Readonly<Record<string, A>>) => Readonly<Record<string, A>>;
+    /**
+     * Removes all `None` values from a `Record<string, Option<A>>`, returning a plain `Record<string, A>`.
+     * Useful when building records from fallible lookups.
+     *
+     * @example
+     * ```ts
+     * Rec.compact({ a: Option.some(1), b: Option.none(), c: Option.some(3) });
+     * // { a: 1, c: 3 }
+     * ```
+     */
+    const compact: <A>(data: Readonly<Record<string, Option<A>>>) => Readonly<Record<string, A>>;
+}
+
+/**
+ * String utilities. All transformation functions are data-last and curried so they
+ * compose naturally with `pipe`. Safe parsers return `Option` instead of `NaN`.
+ *
+ * @example
+ * ```ts
+ * import { Str } from "@nlozgachev/pipelined/utils";
+ * import { pipe } from "@nlozgachev/pipelined/composition";
+ *
+ * pipe("  Hello, World!  ", Str.trim, Str.toLowerCase); // "hello, world!"
+ * ```
+ */
+declare namespace Str {
+    /**
+     * Splits a string by a separator. Data-last: use in `pipe`.
+     *
+     * @example
+     * ```ts
+     * pipe("a,b,c", Str.split(",")); // ["a", "b", "c"]
+     * ```
+     */
+    const split: (separator: string | RegExp) => (s: string) => readonly string[];
+    /**
+     * Removes leading and trailing whitespace from a string.
+     *
+     * @example
+     * ```ts
+     * pipe("  hello  ", Str.trim); // "hello"
+     * ```
+     */
+    const trim: (s: string) => string;
+    /**
+     * Returns `true` when the string contains the given substring.
+     *
+     * @example
+     * ```ts
+     * pipe("hello world", Str.includes("world")); // true
+     * pipe("hello world", Str.includes("xyz"));   // false
+     * ```
+     */
+    const includes: (substring: string) => (s: string) => boolean;
+    /**
+     * Returns `true` when the string starts with the given prefix.
+     *
+     * @example
+     * ```ts
+     * pipe("hello world", Str.startsWith("hello")); // true
+     * pipe("hello world", Str.startsWith("world")); // false
+     * ```
+     */
+    const startsWith: (prefix: string) => (s: string) => boolean;
+    /**
+     * Returns `true` when the string ends with the given suffix.
+     *
+     * @example
+     * ```ts
+     * pipe("hello world", Str.endsWith("world")); // true
+     * pipe("hello world", Str.endsWith("hello")); // false
+     * ```
+     */
+    const endsWith: (suffix: string) => (s: string) => boolean;
+    /**
+     * Converts a string to uppercase.
+     *
+     * @example
+     * ```ts
+     * pipe("hello", Str.toUpperCase); // "HELLO"
+     * ```
+     */
+    const toUpperCase: (s: string) => string;
+    /**
+     * Converts a string to lowercase.
+     *
+     * @example
+     * ```ts
+     * pipe("HELLO", Str.toLowerCase); // "hello"
+     * ```
+     */
+    const toLowerCase: (s: string) => string;
+    /**
+     * Splits a string into lines, normalising `\r\n` and `\r` line endings.
+     *
+     * @example
+     * ```ts
+     * Str.lines("one\ntwo\nthree"); // ["one", "two", "three"]
+     * Str.lines("a\r\nb");         // ["a", "b"]
+     * ```
+     */
+    const lines: (s: string) => readonly string[];
+    /**
+     * Splits a string into words on any whitespace boundary, filtering out empty strings.
+     *
+     * @example
+     * ```ts
+     * Str.words("  hello   world  "); // ["hello", "world"]
+     * ```
+     */
+    const words: (s: string) => readonly string[];
+    /**
+     * Safe number parsers that return `Option` instead of `NaN`.
+     */
+    const parse: {
+        /**
+         * Parses a string as an integer (base 10). Returns `None` if the result is `NaN`.
+         *
+         * @example
+         * ```ts
+         * Str.parse.int("42");   // Some(42)
+         * Str.parse.int("3.7");  // Some(3)
+         * Str.parse.int("abc");  // None
+         * ```
+         */
+        int: (s: string) => Option<number>;
+        /**
+         * Parses a string as a floating-point number. Returns `None` if the result is `NaN`.
+         *
+         * @example
+         * ```ts
+         * Str.parse.float("3.14"); // Some(3.14)
+         * Str.parse.float("42");   // Some(42)
+         * Str.parse.float("abc");  // None
+         * ```
+         */
+        float: (s: string) => Option<number>;
+    };
+}
+
+/**
+ * Functional utilities for unique-value collections (`ReadonlySet<A>`). All functions are pure
+ * and data-last — they compose naturally with `pipe`.
+ *
+ * Every "mutating" operation returns a new set; the original is never changed.
+ *
+ * @example
+ * ```ts
+ * import { Uniq } from "@nlozgachev/pipelined/utils";
+ * import { pipe } from "@nlozgachev/pipelined/composition";
+ *
+ * const active = pipe(
+ *   Uniq.fromArray(["alice", "bob", "alice", "carol"]),
+ *   Uniq.remove("bob"),
+ *   Uniq.map(name => name.toUpperCase()),
+ * );
+ * // ReadonlySet { "ALICE", "CAROL" }
+ * ```
+ */
+declare namespace Uniq {
+    /**
+     * Creates an empty unique collection.
+     *
+     * @example
+     * ```ts
+     * Uniq.empty<number>(); // ReadonlySet {}
+     * ```
+     */
+    const empty: <A>() => ReadonlySet<A>;
+    /**
+     * Creates a unique collection containing a single item.
+     *
+     * @example
+     * ```ts
+     * Uniq.singleton(42); // ReadonlySet { 42 }
+     * ```
+     */
+    const singleton: <A>(item: A) => ReadonlySet<A>;
+    /**
+     * Creates a unique collection from an array, automatically discarding duplicates.
+     *
+     * @example
+     * ```ts
+     * Uniq.fromArray([1, 2, 2, 3, 3, 3]); // ReadonlySet { 1, 2, 3 }
+     * Uniq.fromArray([]);                  // ReadonlySet {}
+     * ```
+     */
+    const fromArray: <A>(arr: readonly A[]) => ReadonlySet<A>;
+    /**
+     * Returns `true` if the collection contains the given item.
+     *
+     * @example
+     * ```ts
+     * pipe(Uniq.fromArray([1, 2, 3]), Uniq.has(2)); // true
+     * pipe(Uniq.fromArray([1, 2, 3]), Uniq.has(4)); // false
+     * ```
+     */
+    const has: <A>(item: A) => (s: ReadonlySet<A>) => boolean;
+    /**
+     * Returns the number of items in the collection.
+     *
+     * @example
+     * ```ts
+     * Uniq.size(Uniq.fromArray([1, 2, 3])); // 3
+     * ```
+     */
+    const size: <A>(s: ReadonlySet<A>) => number;
+    /**
+     * Returns `true` if the collection has no items.
+     *
+     * @example
+     * ```ts
+     * Uniq.isEmpty(Uniq.empty()); // true
+     * ```
+     */
+    const isEmpty: <A>(s: ReadonlySet<A>) => boolean;
+    /**
+     * Returns `true` if every item in `set` also exists in `other`.
+     *
+     * @example
+     * ```ts
+     * pipe(Uniq.fromArray([1, 2]), Uniq.isSubsetOf(Uniq.fromArray([1, 2, 3]))); // true
+     * pipe(Uniq.fromArray([1, 4]), Uniq.isSubsetOf(Uniq.fromArray([1, 2, 3]))); // false
+     * pipe(Uniq.empty<number>(), Uniq.isSubsetOf(Uniq.fromArray([1, 2, 3])));   // true
+     * ```
+     */
+    const isSubsetOf: <A>(other: ReadonlySet<A>) => (s: ReadonlySet<A>) => boolean;
+    /**
+     * Returns a new collection with the item added. If the item is already present, returns the
+     * original collection unchanged.
+     *
+     * @example
+     * ```ts
+     * pipe(Uniq.fromArray([1, 2]), Uniq.insert(3)); // ReadonlySet { 1, 2, 3 }
+     * pipe(Uniq.fromArray([1, 2]), Uniq.insert(2)); // ReadonlySet { 1, 2 } — unchanged
+     * ```
+     */
+    const insert: <A>(item: A) => (s: ReadonlySet<A>) => ReadonlySet<A>;
+    /**
+     * Returns a new collection with the item removed. If the item is not present, returns the
+     * original collection unchanged.
+     *
+     * @example
+     * ```ts
+     * pipe(Uniq.fromArray([1, 2, 3]), Uniq.remove(2)); // ReadonlySet { 1, 3 }
+     * pipe(Uniq.fromArray([1, 2, 3]), Uniq.remove(4)); // ReadonlySet { 1, 2, 3 } — unchanged
+     * ```
+     */
+    const remove: <A>(item: A) => (s: ReadonlySet<A>) => ReadonlySet<A>;
+    /**
+     * Applies `f` to each item, returning a new collection of the results. Duplicate results are
+     * automatically merged.
+     *
+     * @example
+     * ```ts
+     * pipe(Uniq.fromArray([1, 2, 3, 4]), Uniq.map(n => n % 3)); // ReadonlySet { 1, 2, 0 }
+     * ```
+     */
+    const map: <A, B>(f: (a: A) => B) => (s: ReadonlySet<A>) => ReadonlySet<B>;
+    /**
+     * Returns a new collection containing only the items for which the predicate returns `true`.
+     *
+     * @example
+     * ```ts
+     * pipe(Uniq.fromArray([1, 2, 3, 4, 5]), Uniq.filter(n => n % 2 === 0));
+     * // ReadonlySet { 2, 4 }
+     * ```
+     */
+    const filter: <A>(predicate: (a: A) => boolean) => (s: ReadonlySet<A>) => ReadonlySet<A>;
+    /**
+     * Returns a new collection containing all items from both collections.
+     *
+     * @example
+     * ```ts
+     * pipe(Uniq.fromArray([1, 2, 3]), Uniq.union(Uniq.fromArray([2, 3, 4])));
+     * // ReadonlySet { 1, 2, 3, 4 }
+     * ```
+     */
+    const union: <A>(other: ReadonlySet<A>) => (s: ReadonlySet<A>) => ReadonlySet<A>;
+    /**
+     * Returns a new collection containing only the items that appear in both collections.
+     *
+     * @example
+     * ```ts
+     * pipe(Uniq.fromArray([1, 2, 3]), Uniq.intersection(Uniq.fromArray([2, 3, 4])));
+     * // ReadonlySet { 2, 3 }
+     * ```
+     */
+    const intersection: <A>(other: ReadonlySet<A>) => (s: ReadonlySet<A>) => ReadonlySet<A>;
+    /**
+     * Returns a new collection containing only the items from `set` that do not appear in `other`.
+     *
+     * @example
+     * ```ts
+     * pipe(Uniq.fromArray([1, 2, 3, 4]), Uniq.difference(Uniq.fromArray([2, 4])));
+     * // ReadonlySet { 1, 3 }
+     * ```
+     */
+    const difference: <A>(other: ReadonlySet<A>) => (s: ReadonlySet<A>) => ReadonlySet<A>;
+    /**
+     * Folds the collection into a single value by applying `f` to each item in insertion order.
+     *
+     * @example
+     * ```ts
+     * Uniq.reduce(0, (acc, n) => acc + n)(Uniq.fromArray([1, 2, 3])); // 6
+     * ```
+     */
+    const reduce: <A, B>(init: B, f: (acc: B, a: A) => B) => (s: ReadonlySet<A>) => B;
+    /**
+     * Converts the collection to a readonly array in insertion order.
+     *
+     * @example
+     * ```ts
+     * Uniq.toArray(Uniq.fromArray([3, 1, 2])); // [3, 1, 2]
+     * ```
+     */
+    const toArray: <A>(s: ReadonlySet<A>) => readonly A[];
+}
+
+export { Arr, Dict, Num, Rec, Str, Uniq };