extra-iterable/index.d.ts

An [iterable] is a sequence of values.<br>

/** End of iterable. */ export declare const END: any;
/**
 * Handle reading of a single value.
 * @returns value
 */ export type ReadFunction<T> = () => T;
/**
 * Handle combining of two values.
 * @param a a value
 * @param b another value
 * @returns combined value
 */ export type CombineFunction<T> = (a: T, b: T) => T;
/**
 * Handle comparison of two values.
 * @param a a value
 * @param b another value
 * @returns a<b: -ve, a=b: 0, a>b: +ve
 */ export type CompareFunction<T> = (a: T, b: T) => number;
/**
 * Handle processing of values in an iterable.
 * @param v value in iterable
 * @param i index of value in iterable
 * @param x iterable containing the value
 */ export type ProcessFunction<T> = (v: T, i: number, x: Iterable<T>) => void;
/**
 * Handle selection of values in an iterable.
 * @param v value in iterable
 * @param i index of value in iterable
 * @param x iterable containing the value
 * @returns selected?
 */ export type TestFunction<T> = (v: T, i: number, x: Iterable<T>) => boolean;
/**
 * Handle transformation of a value to another.
 * @param v value in iterable
 * @param i index of value in iterable
 * @param x iterable containing the value
 * @returns transformed value
 */ export type MapFunction<T, U> = (v: T, i: number, x: Iterable<T> | null) => U;
/**
 * Handle reduction of multiple values into a single value.
 * @param acc accumulator (temporary result)
 * @param v value in iterable
 * @param i index of value in iterable
 * @param x iterable containing the value
 * @returns reduced value
 */ export type ReduceFunction<T, U> = (acc: U, v: T, i: number, x: Iterable<T>) => U;
/**
 * Handle ending of a combined iterable.
 * @param dones iᵗʰ iterable done?
 * @returns combined iterable done?
 */ export type EndFunction = (dones: boolean[]) => boolean;
/**
 * Check if value is an iterable.
 * @param v a value
 * @returns v is iterable?
 */ export declare function is(v: unknown): v is Iterable<unknown>;
/**
 * Check if value is an iterator.
 * @param v a value
 * @returns v implements \{next(), return?(), throw?()\}?
 */ export declare function isIterator(v: unknown): v is Iterator<unknown>;
/**
 * Check if value is a list (iterable & !string).
 * @param v a value
 * @returns v is list?
 */ export declare function isList<T>(v: Iterable<T>): boolean;
/**
 * Get iterator of an iterable.
 * @param x an iterable
 * @returns x\[\<iterator\>\]()
 */ export declare function iterator<T>(x: Iterable<T>): Iterator<T>;
/**
 * List all indices.
 * @param x an iterable
 * @returns 0, 1, ..., |x|-1
 */ export declare function keys<T>(x: Iterable<T>): IterableIterator<number>;
/**
 * List all values.
 * @param x an iterable
 * @returns v₀, v₁, ... | vᵢ = x[i]
 */ export declare function values<T>(x: Iterable<T>): IterableIterator<T>;
export { values as toOnce };
/**
 * List all index-value pairs.
 * @param x an iterable
 * @returns [0, v₀], [1, v₁], ... | vᵢ = x[i]
 */ export declare function entries<T>(x: Iterable<T>): IterableIterator<[number, T]>;
/**
 * Convert an iterable-like to iterable.
 * @param x an iterator/iterable
 * @returns x as iterable
 */ export declare function from<T>(x: Iterator<T> | Iterable<T>): Iterable<T>;
/**
 * Convert an iterator to iterable.
 * @param x an iterator/iterable
 * @returns x as iterable
 */ export declare function fromIterator<T>(x: Iterator<T>): Iterable<T>;
/**
 * Generate iterable from given number range.
 * @param v start number [0]
 * @param V stop number, excluding [END]
 * @param dv step size [1]
 * @returns v, v+dv, v+2dv, ...
 */ export declare function fromRange(v?: number, V?: number, dv?: number): IterableIterator<number>;
/**
 * Generate iterable from repeated function invocation.
 * @param fn function (impure)
 * @param args arguments
 * @returns fn(...args), fn(...args), ...
 */ export declare function fromInvocation<T, A extends unknown[] = unknown[]>(fn: (...args: A) => T, ...args: A): IterableIterator<T>;
export { fromInvocation as fromCall };
/**
 * Generate iterable from repeated function application.
 * @param fm map function (v, i)
 * @param v start value
 * @returns v, fm(v), fm(fm(v)), ...
 */ export declare function fromApplication<T>(fm: MapFunction<T, T>, v: T): IterableIterator<T>;
export { fromApplication as fromApply };
/**
 * Check if an iterable can iterated only once.
 * @param x an iterable
 * @returns x\[\<iterator\>\] = x?
 */ export declare function isOnce<T>(x: Iterable<T>): x is IterableIterator<T>;
/**
 * Check if an iterable can be iterated many times.
 * @param x an iterable
 * @returns x\[\<iterator\>\] ≠ x?
 */ export declare function isMany<T>(x: Iterable<T>): x is Iterable<T>;
/**
 * Convert a once-like iterable to many.
 * @param x an iterable
 * @param now consume immediately? [false]
 * @returns x' | x' = x; x' can be iterated multiple times
 */ export declare function toMany<T>(x: Iterable<T>, now?: boolean): Iterable<T>;
export { toMany as many };
/**
 * Generate a function that iterates over values upon invocation.
 * @param x an iterable
 * @returns fn | fn() → x[0], fn() → x[1], ...
 */ export declare function toInvokable<T>(x: Iterable<T>): () => T;
export { toInvokable as toCallable };
export { toInvokable as callable };
/**
 * Check if an iterable is empty.
 * @param x an iterable
 * @returns |x| = 0?
 */ export declare function isEmpty<T>(x: Iterable<T>): boolean;
/**
 * Find the length of an iterable.
 * @param x an iterable
 * @param i start index [0]
 * @param I end index [END]
 * @returns |x[i..I]|
 */ export declare function length<T>(x: Iterable<T>, i?: number, I?: number): number;
export { length as size };
/**
 * Get zero-based index for element in iterable.
 * @param x an iterable
 * @param i index (-ve: from right)
 * @returns i' | x[i'] = x[i]; i' ∈ [0, |x|]
 */ export declare function index<T>(x: Iterable<T>, i: number): number;
/**
 * Get index range for part of iterable.
 * @param x an iterable
 * @param i start index (-ve: from right) [0]
 * @param I end index (-ve: from right) [END]
 * @returns [i', I'] | i' ≤ I'; i', I' ∈ [0, |x|]
 */ export declare function indexRange<T>(x: Iterable<T>, i?: number, I?: number): [number, number];
/**
 * Compare two iterables.
 * @param x an iterable
 * @param y another iterable
 * @param fc compare function (a, b)
 * @param fm map function (v, i, x)
 * @returns x<y: -1, x=y: 0, x>y: 1
 */ export declare function compare<T, U = T>(x: Iterable<T>, y: Iterable<T>, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): number;
/**
 * Check if two iterables are equal.
 * @param x an iterable
 * @param y another iterable
 * @param fc compare function (a, b)
 * @param fm map function (v, i, x)
 * @returns x=y?
 */ export declare function isEqual<T, U = T>(x: Iterable<T>, y: Iterable<T>, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): boolean;
/**
 * Get value at index.
 * @param x an iterable
 * @param i index
 * @returns x[i]
 */ export declare function get<T>(x: Iterable<T>, i: number): T | undefined;
/**
 * Get values at indices.
 * @param x an iterable
 * @param is indices (sorted)
 * @returns x[i₀], x[i₁], ... | [i₀, i₁, ...] = is
 */ export declare function getAll<T>(x: Iterable<T>, is: number[]): IterableIterator<T | undefined>;
/**
 * Get value at path in a nested iterable.
 * @param x a nested iterable
 * @param p path
 * @returns x[i₀][i₁][...] | [i₀, i₁, ...] = p
 */ export declare function getPath(x: Iterable<unknown>, p: number[]): unknown;
/**
 * Check if nested iterable has a path.
 * @param x a nested iterable
 * @param p path
 * @returns x[i₀][i₁][...] exists? | [i₀, i₁, ...] = p
 */ export declare function hasPath(x: Iterable<unknown>, p: number[]): boolean;
/**
 * Set value at index.
 * @param x an iterable
 * @param i index
 * @param v value
 * @returns x' | x' = x; x'[i] = v
 */ export declare function set<T>(x: Iterable<T>, i: number, v: T): IterableIterator<T | undefined>;
/**
 * Exchange two values.
 * @param x an iterable
 * @param i an index
 * @param j another index
 * @returns x' | x' = x; x'[i] = x[j]; x'[j] = x[i]
 */ export declare function swap<T>(x: Iterable<T>, i: number, j: number): IterableIterator<T | undefined>;
/**
 * Remove value at index.
 * @param x an iterable
 * @param i index
 * @returns x[0..i] ⧺ x[i+1..]
 */ export declare function remove<T>(x: Iterable<T>, i: number): IterableIterator<T>;
/**
 * Count values which satisfy a test.
 * @param x an iterable
 * @param ft test function (v, i, x)
 * @returns Σtᵢ | tᵢ = 1 if ft(vᵢ) else 0; vᵢ ∈ x
 */ export declare function count<T>(x: Iterable<T>, ft: TestFunction<T>): number;
/**
 * Count occurrences of values.
 * @param x an array
 * @param fm map function (v, i, x)
 * @returns Map \{value ⇒ count\}
 */ export declare function countAs<T, U = T>(x: Iterable<T>, fm?: MapFunction<T, T | U> | null): Map<T | U, number>;
/**
 * Find smallest value.
 * @param x an iterable
 * @param fc compare function (a, b)
 * @param fm map function (v, i, x)
 * @returns v | v ≤ vᵢ; vᵢ ∈ x
 */ export declare function min<T, U = T>(x: Iterable<T>, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): T | undefined;
/**
 * Find largest value.
 * @param x an iterable
 * @param fc compare function (a, b)
 * @param fm map function (v, i, x)
 * @returns v | v ≥ vᵢ; vᵢ ∈ x
 */ export declare function max<T, U = T>(x: Iterable<T>, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): T | undefined;
/**
 * Find smallest and largest values.
 * @param x an iterable
 * @param fc compare function (a, b)
 * @param fm map function (v, i, x)
 * @returns [min_value, max_value]
 */ export declare function range<T, U = T>(x: Iterable<T>, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): [T | undefined, T | undefined];
/**
 * Find smallest entry.
 * @param x an iterable
 * @param fc compare function (a, b)
 * @param fm map function (v, i, x)
 * @returns [min_index, min_value]
 */ export declare function minEntry<T, U = T>(x: Iterable<T>, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): [number, T | undefined];
/**
 * Find largest entry.
 * @param x an iterable
 * @param fc compare function (a, b)
 * @param fm map function (v, i, x)
 * @returns [max_index, max_value]
 */ export declare function maxEntry<T, U = T>(x: Iterable<T>, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): [number, T | undefined];
/**
 * Find smallest and largest entries.
 * @param x an iterable
 * @param fc compare function (a, b)
 * @param fm map function (v, i, x)
 * @returns [min_entry, max_entry]
 */ export declare function rangeEntries<T, U = T>(x: Iterable<T>, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): [[number, T | undefined], [number, T | undefined]];
/**
 * Get part of an iterable.
 * @param x an iterable
 * @param i start index (-ve: from right) [0]
 * @param I end index (-ve: from right) [END]
 * @returns x[i..I]
 */ export declare function slice<T>(x: Iterable<T>, i?: number, I?: number): IterableIterator<T>;
/**
 * Get first value.
 * @param x an iterable
 * @param vd default value
 * @returns x[0] || vd
 */ export declare function head<T>(x: Iterable<T>, vd?: T): T | undefined;
/**
 * Get last value.
 * @param x an iterable
 * @param vd default value
 * @returns x[|x|-1]
 */ export declare function last<T>(x: Iterable<T>, vd?: T): T | undefined;
/**
 * Get values except first.
 * @param x an iterable
 * @returns x[1..|x|]
 */ export declare function tail<T>(x: Iterable<T>): IterableIterator<T>;
export { tail as shift };
/**
 * Get values except last.
 * @param x an iterable
 * @returns x[0..|x|-1]
 */ export declare function init<T>(x: Iterable<T>): IterableIterator<T>;
export { init as pop };
/**
 * Get values from left.
 * @param x an iterable
 * @param n number of values
 * @returns x[0..n]
 */ export declare function left<T>(x: Iterable<T>, n: number): IterableIterator<T>;
/**
 * Get values from right.
 * @param x an iterable
 * @param n number of values
 * @returns x[-n..]
 */ export declare function right<T>(x: Iterable<T>, n: number): IterableIterator<T>;
/**
 * Get values from middle.
 * @param x an iterable
 * @param i start index
 * @param n number of values [1]
 * @returns x[i..i+n]
 */ export declare function middle<T>(x: Iterable<T>, i: number, n?: number): IterableIterator<T>;
/**
 * Keep first n values only.
 * @param x an iterable
 * @param n number of values [1]
 * @returns x[0..n]
 */ export declare function take<T>(x: Iterable<T>, n?: number): IterableIterator<T>;
/**
 * Keep last n values only.
 * @param x an iterable
 * @param n number of values [1]
 * @returns x[-n..]
 */ export declare function takeRight<T>(x: Iterable<T>, n?: number): IterableIterator<T>;
/**
 * Keep values from left, while a test passes.
 * @param x an iterable
 * @param ft test function (v, i, x)
 * @returns x[0..T-1] | ft(x[i]) = true ∀ i ∈ [0, T-1] & ft(x[T]) = false
 */ export declare function takeWhile<T>(x: Iterable<T>, ft: TestFunction<T>): IterableIterator<T>;
/**
 * Keep values from right, while a test passes.
 * @param x an iterable
 * @param ft test function (v, i, x)
 * @returns x[T..] | ft(x[i]) = true ∀ i ∈ [T, |x|-1] & ft(x[T-1]) = false
 */ export declare function takeWhileRight<T>(x: Iterable<T>, ft: TestFunction<T>): IterableIterator<T>;
/**
 * Discard first n values only.
 * @param x an iterable
 * @param n number of values [1]
 * @returns x[n..]
 */ export declare function drop<T>(x: Iterable<T>, n?: number): IterableIterator<T>;
/**
 * Discard last n values only.
 * @param x an iterable
 * @param n number of values [1]
 * @returns x[0..-n]
 */ export declare function dropRight<T>(x: Iterable<T>, n?: number): IterableIterator<T>;
/**
 * Discard values from left, while a test passes.
 * @param x an iterable
 * @param ft test function (v, i, x)
 * @returns x[T..] | ft(x[i]) = true ∀ i ∈ [0, T-1] & ft(x[T]) = false
 */ export declare function dropWhile<T>(x: Iterable<T>, ft: TestFunction<T>): IterableIterator<T>;
/**
 * Discard values from right, while a test passes.
 * @param x an iterable
 * @param ft test function (v, i, x)
 * @returns x[0..T-1] | ft(x[i]) = true ∀ i ∈ [T, |x|-1] & ft(x[T-1]) = false
 */ export declare function dropWhileRight<T>(x: Iterable<T>, ft: TestFunction<T>): IterableIterator<T>;
/**
 * Check if iterable has a value.
 * @param x an iterable
 * @param v search value
 * @param i start index [0]
 * @returns v ∈ x[i..]?
 */ export declare function includes<T>(x: Iterable<T>, v: T, i?: number): boolean;
/**
 * Find first index of a value.
 * @param x an iterable
 * @param v search value
 * @param i start index [0]
 * @returns index of v in x[i..] if found else -1
 */ export declare function indexOf<T>(x: Iterable<T>, v: T, i?: number): number;
/**
 * Find last index of a value.
 * @param x an iterable
 * @param v search value
 * @param i start index [END-1]
 * @returns last index of v in x[0..i] if found else -1
 */ export declare function lastIndexOf<T>(x: Iterable<T>, v: T, i?: number): number;
/**
 * Find first value passing a test.
 * @param x an iterable
 * @param ft test function (v, i, x)
 * @returns first v | ft(v) = true; v ∈ x
 */ export declare function find<T>(x: Iterable<T>, ft: TestFunction<T>): T | undefined;
/**
 * Find last value passing a test.
 * @param x an iterable
 * @param ft test function (v, i, x)
 * @returns last v | ft(v) = true; v ∈ x
 */ export declare function findRight<T>(x: Iterable<T>, ft: TestFunction<T>): T | undefined;
/**
 * Scan from left, while a test passes.
 * @param x an array
 * @param ft test function (v, i, x)
 * @returns first index where test fails
 */ export declare function scanWhile<T>(x: Iterable<T>, ft: TestFunction<T>): number;
/**
 * Scan from right, while a test passes.
 * @param x an iterable
 * @param ft test function (v, i, x)
 * @returns first index where test passes till end
 */ export declare function scanWhileRight<T>(x: Iterable<T>, ft: TestFunction<T>): number;
/**
 * Scan from left, until a test passes.
 * @param x an array
 * @param ft test function (v, i, x)
 * @returns first index where test passes
 */ export declare function scanUntil<T>(x: Iterable<T>, ft: TestFunction<T>): number;
/**
 * Scan from right, until a test passes.
 * @param x an iterable
 * @param ft test function (v, i, x)
 * @returns first index where test fails till end
 */ export declare function scanUntilRight<T>(x: Iterable<T>, ft: TestFunction<T>): number;
/**
 * Find index of first value passing a test.
 * @param x an iterable
 * @param ft test function (v, i, x)
 * @returns first index of value, -1 if not found
 */ export declare function search<T>(x: Iterable<T>, ft: TestFunction<T>): number;
/**
 * Find index of last value passing a test.
 * @param x an iterable
 * @param ft test function (v, i, x)
 * @returns last index of value, -1 if not found
 */ export declare function searchRight<T>(x: Iterable<T>, ft: TestFunction<T>): number;
/**
 * Find indices of values passing a test.
 * @param x an iterable
 * @param ft test function (v, i, x)
 * @returns indices of value
 */ export declare function searchAll<T>(x: Iterable<T>, ft: TestFunction<T>): IterableIterator<number>;
/**
 * Find first index of a value.
 * @param x an iterable
 * @param v search value
 * @param fc compare function (a, b)
 * @param fm map function (v, i, x)
 * @returns first index of value, -1 if not found
 */ export declare function searchValue<T, U = T>(x: Iterable<T>, v: T, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): number;
/**
 * Find last index of a value.
 * @param x an iterable
 * @param v search value
 * @param fc compare function (a, b)
 * @param fm map function (v, i, x)
 * @returns last index of value, -1 if not found
 */ export declare function searchValueRight<T, U = T>(x: Iterable<T>, v: T, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): number;
/**
 * Find indices of a value.
 * @param x an iterable
 * @param v search value
 * @param fc compare function (a, b)
 * @param fm map function (v, i, x)
 * @returns indices of value
 */ export declare function searchValueAll<T, U = T>(x: Iterable<T>, v: T, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): IterableIterator<number>;
/**
 * Find first index of an infix.
 * @param x an iterable
 * @param y search infix
 * @param fc compare function (a, b)
 * @param fm map function (v, i, x)
 * @returns first i | x[i..i+|y|] = y else -1
 */ export declare function searchInfix<T, U = T>(x: Iterable<T>, y: Iterable<T>, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): number;
/**
 * Find last index of an infix.
 * @param x an iterable
 * @param y search infix
 * @param fc compare function (a, b)
 * @param fm map function (v, i, x)
 * @returns first i | x[i..i+|y|] = y else -1
 */ export declare function searchInfixRight<T, U = T>(x: Iterable<T>, y: Iterable<T>, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): number;
/**
 * Find indices of an infix.
 * @param x an iterable
 * @param y search infix
 * @param fc compare function (a, b)
 * @param fm map function (v, i, x)
 * @returns i₀, i₁, ... | x[j..j+|y|] = y; j ∈ [i₀, i₁, ...]
 */ export declare function searchInfixAll<T, U = T>(x: Iterable<T>, y: Iterable<T>, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): IterableIterator<number>;
/**
 * Find first index of a subsequence.
 * @param x an iterable
 * @param y search subsequence
 * @param fc compare function (a, b)
 * @param fm map function (v, i, x)
 * @returns start index of subsequence, -1 if not found
 */ export declare function searchSubsequence<T, U = T>(x: Iterable<T>, y: Iterable<T>, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): number;
/**
 * Check if iterable has a value.
 * @param x an iterable
 * @param v search value
 * @param fc compare function (a, b)
 * @param fm map function (v, i, x)
 * @returns v ∈ x?
 */ export declare function hasValue<T, U = T>(x: Iterable<T>, v: T, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): boolean;
/**
 * Check if iterable starts with a prefix.
 * @param x an iterable
 * @param y search prefix
 * @param fc compare function (a, b)
 * @param fm map function (v, i, x)
 * @returns x[0..|y|] = y?
 */ export declare function hasPrefix<T, U = T>(x: Iterable<T>, y: Iterable<T>, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): boolean;
/**
 * Check if iterable ends with a suffix.
 * @param x an iterable
 * @param y seach suffix
 * @param fc compare function (a, b)
 * @param fm map function (v, i, x)
 * @returns x[|x|-|y|..] = y?
 */ export declare function hasSuffix<T, U = T>(x: Iterable<T>, y: Iterable<T>, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): boolean;
/**
 * Check if iterable contains an infix.
 * @param x an iterable
 * @param y search infix
 * @param fc compare function (a, b)
 * @param fm map function (v, i, x)
 * @returns x[i..I] = y for some i, I?
 */ export declare function hasInfix<T, U = T>(x: Iterable<T>, y: Iterable<T>, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): boolean;
/**
 * Check if iterable has a subsequence.
 * @param x an iterable
 * @param y search subsequence
 * @param fc compare function (a, b)
 * @param fm map function (v, i, x)
 * @returns x[i₀] ⧺ x[i₁] ⧺ ... = y, for some i₀, i₁, ...? | i₀ < i₁ < ...
 */ export declare function hasSubsequence<T, U = T>(x: Iterable<T>, y: Iterable<T>, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): boolean;
/**
 * Call a function for each value.
 * @param x an iterable
 * @param fp process function (v, i, x)
 */ export declare function forEach<T>(x: Iterable<T>, fp: ProcessFunction<T>): void;
/**
 * Check if any value satisfies a test.
 * @param x an iterable
 * @param ft test function (v, i, x)
 * @returns true if ft(vᵢ) = true for some vᵢ ∈ x
 */ export declare function some<T>(x: Iterable<T>, ft?: TestFunction<T> | null): boolean;
/**
 * Check if all values satisfy a test.
 * @param x an iterable
 * @param ft test function (v, i, x)
 * @returns true if ft(vᵢ) = true for all vᵢ ∈ x
 */ export declare function every<T>(x: Iterable<T>, ft?: TestFunction<T> | null): boolean;
/**
 * Transform values of an iterable.
 * @param x an iterable
 * @param fm map function (v, i, x)
 * @returns fm(v₀), fm(v₁), ... | vᵢ ∈ x
 */ export declare function map<T, U>(x: Iterable<T>, fm: MapFunction<T, U>): IterableIterator<U>;
/**
 * Reduce values of iterable to a single value.
 * @param x an iterable
 * @param fr reduce function (acc, v, i, x)
 * @param acc initial value
 * @returns fr(fr(acc, v₀), v₁)... | fr(acc, v₀) = v₀ if acc not given
 */ export declare function reduce<T, U = T>(x: Iterable<T>, fr: ReduceFunction<T, U>, acc?: U): U | undefined;
/**
 * Keep the values which pass a test.
 * @param x an iterable
 * @param ft test function (v, i, x)
 * @returns v₀, v₁, ... | ft(vᵢ) = true; vᵢ ∈ x
 */ export declare function filter<T>(x: Iterable<T>, ft: TestFunction<T>): IterableIterator<T>;
export { filter as findAll };
/**
 * Keep the values at given indices.
 * @param x an iterable
 * @param is indices (sorted)
 * @returns v₀, v₁, ... | vᵢ = x[i]; i ∈ is
 */ export declare function filterAt<T>(x: Iterable<T>, is: number[]): IterableIterator<T>;
/**
 * Discard the values which pass a test.
 * @param x an iterable
 * @param ft test function (v, i, x)
 * @returns v₀, v₁, ... | ft(vᵢ) = false; vᵢ ∈ x
 */ export declare function reject<T>(x: Iterable<T>, ft: TestFunction<T>): IterableIterator<T>;
/**
 * Discard the values at given indices.
 * @param x an iterable
 * @param is indices (sorted)
 * @returns v₀, v₁, ... | vᵢ = x[i]; i ∉ is
 */ export declare function rejectAt<T>(x: Iterable<T>, is: number[]): IterableIterator<T>;
/**
 * Produce accumulating values.
 * @param x an iterable
 * @param fr reduce function (acc, v, i, x)
 * @param acc initial value
 * @returns fr(acc, v₀), fr(fr(acc, v₀), v₁), ... | fr(acc, v₀) = v₀ if acc not given
 */ export declare function accumulate<T, U = T>(x: Iterable<T>, fr: ReduceFunction<T, T | U>, acc?: T | U): IterableIterator<T | U>;
/**
 * Flatten nested iterable to given depth.
 * @param x a nested iterable
 * @param n maximum depth (-1 ⇒ all)
 * @param fm map function (v, i, x)
 * @param ft flatten test (v, i, x) [isList]
 * @returns flat iterable
 */ export declare function flat(x: Iterable<unknown>, n?: number, fm?: MapFunction<unknown, unknown> | null, ft?: TestFunction<unknown> | null): IterableIterator<unknown>;
/**
 * Flatten nested iterable, based on map function.
 * @param x a nested iterable
 * @param fm map function (v, i, x)
 * @param ft flatten test (v, i, x) [isList]
 * @returns flat iterable
 */ export declare function flatMap(x: Iterable<unknown>, fm?: MapFunction<unknown, unknown> | null, ft?: TestFunction<unknown> | null): IterableIterator<unknown>;
/**
 * Combine values from iterables.
 * @param xs iterables
 * @param fm map function (vs, i, xs)
 * @param fe end function (dones) [some]
 * @param vd default value
 * @returns fm([x₀[0], x₁[0], ...]), fm([x₀[1], x₁[1], ...]), ...
 */ export declare function zip<T, U = T[]>(xs: Iterable<T>[], fm?: MapFunction<T[], T[] | U> | null, fe?: EndFunction | null, vd?: T): IterableIterator<T[] | U>;
/**
 * Fill with given value.
 * @param x an iterable
 * @param v value
 * @param i start index [0]
 * @param I end index [END]
 * @returns x' | x' = x; x'[i..I] = v
 */ export declare function fill<T>(x: Iterable<T>, v: T, i?: number, I?: number): IterableIterator<T>;
/**
 * Add values to the end.
 * @param x an iterable
 * @param vs values to add
 * @returns ...x, ...vs
 */ export declare function push<T>(x: Iterable<T>, ...vs: T[]): IterableIterator<T>;
/**
 * Add values to the start.
 * @param x an iterable
 * @param vs values to add
 * @returns ...vs, ...x
 */ export declare function unshift<T>(x: Iterable<T>, ...vs: T[]): IterableIterator<T>;
/**
 * Copy part of iterable to another.
 * @param x target iterable
 * @param y source iterable
 * @param j write index [0]
 * @param i read start index [0]
 * @param I read end index [END]
 * @returns x[0..j] ⧺ y[i..I] ⧺ x[j+I-i..]
 */ export declare function copy<T>(x: Iterable<T>, y: Iterable<T>, j?: number, i?: number, I?: number): IterableIterator<T | undefined>;
/**
 * Copy part of iterable within.
 * @param x an iterable
 * @param j write index [0]
 * @param i read start index [0]
 * @param I read end index [END]
 * @returns x[0..j] ⧺ x[i..I] ⧺ x[j+I-i..]
 */ export declare function copyWithin<T>(x: Iterable<T>, j?: number, i?: number, I?: number): IterableIterator<T | undefined>;
/**
 * Move part of iterable within.
 * @param x an iterable
 * @param j write index [0]
 * @param i read start index [0]
 * @param I read end index [END]
 * @returns x[0..j] ⧺ x[i..I] ⧺ x[j..i] ⧺ x[I..]
 */ export declare function moveWithin<T>(x: Iterable<T>, j?: number, i?: number, I?: number): IterableIterator<T>;
/**
 * Remove or replaces existing values.
 * @param x an iterable
 * @param i remove index [0]
 * @param n number of values to remove [rest]
 * @param vs values to insert
 * @returns x[0..i] ⧺ vs ⧺ x[i+n..]
 */ export declare function splice<T>(x: Iterable<T>, i?: number, n?: number, ...vs: T[]): IterableIterator<T>;
/**
 * Break iterable considering test as separator.
 * @param x an iterable
 * @param ft test function (v, i, x)
 * @returns x[j..k] ⧺ x[l..m] ⧺ ... | ft(x[i]) = true; i = 0..j / k..l / ...
 */ export declare function split<T>(x: Iterable<T>, ft: TestFunction<T>): IterableIterator<T[]>;
/**
 * Break iterable considering indices as separator.
 * @param x an iterable
 * @param is indices (sorted)
 * @returns x[j..k] ⧺ x[l..m] ⧺ ... | ft(x[i]) = true; i = 0..j / k..l / ...; i ∈ is
 */ export declare function splitAt<T>(x: Iterable<T>, is: number[]): IterableIterator<T[]>;
/**
 * Break iterable when test passes.
 * @param x an iterable
 * @param ft test function (v, i, x)
 * @returns x[0..j] ⧺ x[j..k] ⧺ ... | ft(x[i]) = true; i = j, k, ...
 */ export declare function cut<T>(x: Iterable<T>, ft: TestFunction<T>): IterableIterator<T[]>;
/**
 * Break iterable after test passes.
 * @param x an iterable
 * @param ft test function (v, i, x)
 * @returns x[0..j+1] ⧺ x[j+1..k] ⧺ ... | ft(x[i]) = true; i = j, k, ...
 */ export declare function cutRight<T>(x: Iterable<T>, ft: TestFunction<T>): IterableIterator<T[]>;
/**
 * Break iterable at given indices.
 * @param x an iterable
 * @param is split indices (sorted)
 * @returns x[0..j] ⧺ x[j..k] ⧺ ... | ft(x[i]) = true; i = j, k, ...; i ∈ is
 */ export declare function cutAt<T>(x: Iterable<T>, is: Iterable<number>): IterableIterator<T[]>;
/**
 * Break iterable after given indices.
 * @param x an iterable
 * @param is split indices (sorted)
 * @returns x[0..j+1] ⧺ x[j+1..k] ⧺ ... | ft(x[i]) = true; i = j, k, ...; i ∈ is
 */ export declare function cutAtRight<T>(x: Iterable<T>, is: Iterable<number>): IterableIterator<T[]>;
/**
 * Keep similar values together and in order.
 * @param x an iterable
 * @param fc compare function (a, b)
 * @param fm map function (v, i, x)
 * @returns x[0..k], x[k..l], ... | fc(x[i], x[j]) = 0; i, j = 0..k / k..l / ...
 */ export declare function group<T, U = T>(x: Iterable<T>, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): IterableIterator<T[]>;
/**
 * Segregate values by test result.
 * @param x an array
 * @param ft test function (v, i, x)
 * @returns [satisfies, doesnt]
 */ export declare function partition<T>(x: Iterable<T>, ft: TestFunction<T>): [T[], T[]];
/**
 * Segregate values by similarity.
 * @param x an array
 * @param fm map function (v, i, x)
 * @returns Map \{key ⇒ values\}
 */ export declare function partitionAs<T, U = T>(x: Iterable<T>, fm?: MapFunction<T, T | U> | null): Map<T | U, T[]>;
/**
 * Break iterable into chunks of given size.
 * @param x an iterable
 * @param n chunk size [1]
 * @param s chunk step [n]
 * @returns x[0..n], x[s..s+n], x[2s..2s+n], ...
 */ export declare function chunk<T>(x: Iterable<T>, n?: number, s?: number): IterableIterator<T[]>;
/**
 * Obtain values that cycle through an iterable.
 * @param x an iterable
 * @param i start index [0]
 * @param n number of values [-1 ⇒ Inf]
 * @returns x[i..] ⧺ x ⧺ x ⧺ ... with upto n values
 */ export declare function cycle<T>(x: Iterable<T>, i?: number, n?: number): IterableIterator<T>;
/**
 * Repeat an iterable given times.
 * @param x an iterable
 * @param n times [-1 ⇒ Inf]
 * @returns ...x, ...x, ...(n times)
 */ export declare function repeat<T>(x: Iterable<T>, n?: number): IterableIterator<T>;
/**
 * Reverse the values.
 * @param x an iterable
 * @returns x[|x|-1], x[|x|-2], ..., x[1], x[0]
 */ export declare function reverse<T>(x: Iterable<T>): IterableIterator<T>;
/**
 * Rotate values in iterable.
 * @param x an iterable
 * @param n rotate amount (+ve: left, -ve: right) [0]
 * @returns x[n..] ⧺ x[0..n]
 */ export declare function rotate<T>(x: Iterable<T>, n?: number): IterableIterator<T>;
/**
 * Place a separator between every value.
 * @param x an iterable
 * @param v separator
 * @returns x[0], v, x[1], v, ..., x[|x|-1]
 */ export declare function intersperse<T>(x: Iterable<T>, v: T): IterableIterator<T>;
/**
 * Estimate new values between existing ones.
 * @param x an iterable
 * @param fc combine function (a, b)
 * @returns x[0], fc(x[0], x[1]), x[1], fc(x[1], x[2]), ..., x[|x|-1]
 */ export declare function interpolate<T>(x: Iterable<T>, fc: CombineFunction<T>): IterableIterator<T>;
/**
 * Place values of an iterable between another.
 * @param x an iterable
 * @param y another iterable
 * @param m number of values from x [1]
 * @param n number of values from y [1]
 * @param s step size for x [m]
 * @param t step size for y [n]
 * @returns x[0..m], y[0..n], x[s..s+m], y[t..t+n], ..., x[k*s..|x|-1] | k ∈ W
 */ export declare function intermix<T>(x: Iterable<T>, y: Iterable<T>, m?: number, n?: number, s?: number, t?: number): IterableIterator<T>;
/**
 * Place values from iterables alternately.
 * @param xs iterables
 * @returns x₀[0], x₁[0], ..., x₀[1], x₁[0], ... | [x₀, x₁, ...] = xs
 */ export declare function interleave<T>(xs: Iterable<T>[]): IterableIterator<T>;
/**
 * Append values from iterables.
 * @param xs iterables
 * @returns ...x₀, ...x₁, ... | [x₀, x₁, ...] = xs
 */ export declare function concat<T>(...xs: Iterable<T>[]): IterableIterator<T>;
/**
 * Merge values from sorted iterables.
 * @param xs iterables
 * @param fc compare function (a, b)
 * @param fm map function (v, i, x)
 * @returns sort(concat(...xs))
 */ export declare function merge<T, U = T>(xs: Iterable<T>[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): IterableIterator<T>;
/**
 * Join values together into a string.
 * @param x an iterable
 * @param sep separator [,]
 * @returns "$\{v₀\}$\{sep\}$\{v₁\}..." | vᵢ ∈ x
 */ export declare function join<T>(x: Iterable<T>, sep?: string): string;
/**
 * Check if there are no duplicate values.
 * @param x an array
 * @param fc compare function (a, b)
 * @param fm map function (v, i, x)
 * @returns ∀ vᵢ, vⱼ ∈ x, is vᵢ ≠ vⱼ?
 */ export declare function isUnique<T, U = T>(x: Iterable<T>, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): boolean;
/**
 * Checks if arrays have no value in common.
 * @param x an array
 * @param y another array
 * @param fc compare function (a, b)
 * @param fm map function (v, i, x)
 * @returns x ∩ y = Φ?
 */ export declare function isDisjoint<T, U = T>(x: Iterable<T>, y: Iterable<T>, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): boolean;
/**
 * Remove duplicate values.
 * @param x an iterable
 * @param fc compare function (a, b)
 * @param fm map function (v, i, x)
 * @returns v₀, v₁, ... | vᵢ ∈ x; vᵢ ≠ vⱼ ∀ i, j
 */ export declare function unique<T, U = T>(x: Iterable<T>, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): IterableIterator<T>;
/**
 * Obtain values present in any iterable.
 * @param x an iterable
 * @param y another iterable
 * @param fc compare function (a, b)
 * @param fm map function (v, i, x)
 * @returns x ∪ y = \{v | v ∈ x or v ∈ y\}
 */ export declare function union<T, U = T>(x: Iterable<T>, y: Iterable<T>, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): IterableIterator<T>;
/**
 * Obtain values present in both iterables.
 * @param x an iterable
 * @param y another iterable
 * @param fc compare function (a, b)
 * @param fm map function (v, i, x)
 * @returns x ∩ y = \{v | v ∈ x, v ∈ y\}
 */ export declare function intersection<T, U = T>(x: Iterable<T>, y: Iterable<T>, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): IterableIterator<T>;
/**
 * Obtain values not present in another iterable.
 * @param x an iterable
 * @param y another iterable
 * @param fc compare function (a, b)
 * @param fm map function (v, i, x)
 * @returns x - y = \{v | v ∈ x, v ∉ y\}
 */ export declare function difference<T, U = T>(x: Iterable<T>, y: Iterable<T>, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): IterableIterator<T>;
/**
 * Obtain values not present in both iterables.
 * @param x an iterable
 * @param y another iterable
 * @param fc compare function (a, b)
 * @param fm map function (v, i, x)
 * @returns x-y ∪ y-x
 */ export declare function symmetricDifference<T, U = T>(x: Iterable<T>, y: Iterable<T>, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): IterableIterator<T>;
/**
 * List cartesian product of iterables.
 * @param xs iterables
 * @param fm map function (vs, i)
 * @returns x₀ × x₁ × ... = \{[v₀, v₁, ...] | v₀ ∈ x₀, v₁ ∈ x₁, ...] \}
 */ export declare function cartesianProduct<T, U = T>(xs: Iterable<T>[], fm?: MapFunction<T[], T[] | U> | null): IterableIterator<T[] | U>;