/** Entries is an array of index-value pairs, with unique indices. */ export type Entries = [number, T][]; /** IEntries is a list of index-value pairs, with unique indices. */ export type IEntries = Iterable<[number, T]>; /** Lists is a pair of index array and value array, with unique indices. */ export type Lists = [number[], T[]]; /** ILists is a pair of index iterable list and value iterable list, with unique indices. */ export type ILists = [Iterable, Iterable]; /** * Handle reading of a single value. * @returns value */ export type ReadFunction = () => T; /** * Handle combining of two values. * @param a a value * @param b another value * @returns combined value */ export type CombineFunction = (a: T, b: T) => T; /** * Handle comparison of two values. * @param a a value * @param b another value * @returns ab: +ve */ export type CompareFunction = (a: T, b: T) => number; /** * Handle processing of values in an array. * @param v value in array * @param i index of value in array * @param x array containing the value */ export type ProcessFunction = (v: T, i: number, x: T[] | null) => void; /** * Handle selection of values in an array. * @param v value in array * @param i index of value in array * @param x array containing the value * @returns selected? */ export type TestFunction = (v: T, i: number, x: T[] | null) => boolean; /** * Handle transformation of a value to another. * @param v value in array * @param i index of value in array * @param x array containing the value * @returns transformed value */ export type MapFunction = (v: T, i: number, x: T[] | null) => U; /** * Handle reduction of multiple values into a single value. * @param acc accumulator (temporary result) * @param v value in array * @param i index of value in array * @param x array containing the value * @returns reduced value */ export type ReduceFunction = (acc: U, v: T, i: number, x: T[] | null) => U; /** * Handle ending of a combined array. * @param dones iᵗʰ array done? * @returns combined array done? */ export type EndFunction = (dones: boolean[]) => boolean; /** * Handle swapping of two values in an array. * @param x an array (updated!) * @param i an index * @param j another index * @returns x | x[i] ⇔ x[j] */ export type SwapFunction = (x: T[], i: number, j: number) => T[]; /** * Generate array from given number range. * @param v start number * @param V end number, excluding * @param dv step size [1] * @returns [v, v+dv, v+2dv, ...] */ export declare function fromRange(v: number, V: number, dv?: number): number[]; /** * Generate array from repeated function invocation. * @param fn function * @param n number of values * @returns [fn(), fn(), ...] */ export declare function fromInvocation(fn: () => T, n: number): T[]; export { fromInvocation as fromCall }; /** * Generate array from repeated function application. * @param fm map function (v, i) * @param v start value * @param n number of values * @returns [v, fm(v), fm(fm(v)), ...] */ export declare function fromApplication(fm: MapFunction, v: T, n: number): T[]; export { fromApplication as fromApply }; /** * Convert an iterable to array. * @param x an iterable * @returns x as array */ export declare function fromIterable(x: Iterable): T[]; export { fromIterable as from }; /** * Convert an iterable to array! * @param x an iterable (updatable if array!) * @returns x as array */ export declare function fromIterable$(x: Iterable): T[]; export { fromIterable$ as from$ }; /** * Shallow clone an array. * @param x an array * @returns shallow clone of x */ export declare function shallowClone(x: T[]): T[]; export { shallowClone as clone }; /** * Deep clone an array. * @param x an array * @returns deep clone of x */ export declare function deepClone(x: T[]): T[]; /** * Check if value is an array. * @param v a value * @returns v is an array? */ export declare function is(v: unknown): v is unknown[]; /** * Obtain all indices. * @param x an array * @returns [0, 1, ..., |x|-1] */ export declare function keys(x: T[]): number[]; /** * List all indices. * @param x an array * @returns 0, 1, ..., |x|-1 */ export declare function ikeys(x: T[]): IterableIterator; /** * Get all values. * @param x an array * @returns [v₀, v₁, ...] | vᵢ = x[i] */ export declare function values(x: T[]): T[]; /** * List all values. * @param x an array * @returns v₀, v₁, ... | vᵢ = x[i] */ export declare function ivalues(x: T[]): IterableIterator; /** * Obtain all index-value pairs. * @param x an array * @returns [[0, v₀], [1, v₁], ...] | vᵢ = x[i] */ export declare function entries(x: T[]): Entries; /** * List all index-value pairs. * @param x an array * @returns [0, v₀], [1, v₁], ... | vᵢ = x[i] */ export declare function ientries(x: T[]): IEntries; /** * Get zero-based index for an element in array. * @param x an array * @param i ±index * @returns i' | x[i'] = x[i]; i' ∈ [0, |x|] */ export declare function index(x: T[], i: number): number; /** * Get zero-based index range for part of array. * @param x an array * @param i begin ±index [0] * @param I end ±index (exclusive) [|x|] * @returns [i', I'] | i' ≤ I'; i', I' ∈ [0, |x|] */ export declare function indexRange(x: T[], i?: number, I?: number): [number, number]; /** * Check if an array is empty. * @param x an array * @returns |x| = 0? */ export declare function isEmpty(x: T[]): boolean; /** * Find the length of an array. * @param x an array * @param i begin ±index [0] * @param I end ±index (exclusive) [X] * @returns |x[i..I]| */ export declare function length(x: T[], i?: number, I?: number): number; export { length as size }; /** * Resize an array to given length! * @param x an array * @param n new length * @param vd default value * @returns resized x */ export declare function resize$(x: T[], n: number, vd: T): T[]; /** * Remove all elements from an array! * @param x an array (updated!) * @returns cleared x */ export declare function clear$(x: T[]): T[]; /** * Get value at index. * @param x an array * @param i index * @returns x[i] */ export declare function get(x: T[], i: number): T; export { get as at }; /** * Get values at indices. * @param x an array * @param is indices * @returns [x[i₀], x[i₁], ...] | [i₀, i₁, ...] = is */ export declare function getAll(x: T[], is: number[]): T[]; /** * Get value at path in a nested array. * @param x a nested array * @param p path * @returns x[i₀][i₁][...] | [i₀, i₁, ...] = p */ export declare function getPath(x: unknown[], p: number[]): unknown; /** * Check if nested array has a path. * @param x a nested array * @param p path * @returns x[i₀][i₁][...] exists? | [i₀, i₁, ...] = p */ export declare function hasPath(x: unknown[], p: number[]): boolean; /** * Set value at index. * @param x an array * @param i index * @param v value * @returns x' | x' = x; x'[i] = v */ export declare function set(x: T[], i: number, v: T): T[]; export { set as with }; /** * Set value at index! * @param x an array (updated!) * @param i index * @param v value * @returns x | x[i] = v */ export declare function set$(x: T[], i: number, v: T): T[]; /** * Set value at path in a nested array! * @param x a nested array (updated!) * @param p path * @param v value * @returns x | x[i₀][i₁][...] = v; [i₀, i₁, ...] = p */ export declare function setPath$(x: unknown[], p: number[], v: unknown): unknown[]; /** * Exchange two values. * @param x an array * @param i an index * @param j another index * @returns x' | x' = x; x'[i] = x[j]; x'[j] = x[i] */ export declare function swap(x: T[], i: number, j: number): T[]; /** * Exchange two values! * @param x an array (updated!) * @param i an index * @param j another index * @returns x | x[i] ⇔ x[j] */ export declare function swap$(x: T[], i: number, j: number): T[]; /** * Exchange two ranges of values. * @param x an array * @param i begin index of first range * @param I end index of first range (exclusive) * @param j begin index of second range * @param J end index of second range (exclusive) * @returns x' | x' = x; x'[i..I] = x[j..J]; x'[j..J] = x[i..I] */ export declare function swapRanges(x: T[], i: number, I: number, j: number, J: number): T[]; /** * Exchange two ranges of values! * @param x an array (updated!) * @param i begin index of first range * @param I end index of first range (exclusive) * @param j begin index of second range * @param J end index of second range (exclusive) * @returns x | x[i..I] ⇔ x[j..J] */ export declare function swapRanges$(x: T[], i: number, I: number, j: number, J: number): T[]; /** * Remove value at index. * @param x an array * @param i index * @returns x[0..i] ⧺ x[i+1..] */ export declare function remove(x: T[], i: number): T[]; /** * Remove value at index! * @param x an array (updated!) * @param i index * @returns x \\: [i] */ export declare function remove$(x: T[], i: number): T[]; /** * Remove value at path in a nested array! * @param x a nested array (updated!) * @param p path * @returns x \\: [i₀][i₁][...] | [i₀, i₁, ...] = p */ export declare function removePath$(x: unknown[], p: number[]): unknown[]; /** * Examine if array is sorted. * @param x an array * @param fc compare function (a, b) * @param fm map function (v, i, x) * @returns x is sorted? */ export declare function isSorted(x: T[], fc?: CompareFunction | null, fm?: MapFunction | null): boolean; /** * Examine if array has an unsorted value. * @param x an array * @param fc compare function (a, b) * @param fm map function (v, i, x) * @returns x is not sorted? */ export declare function hasUnsortedValue(x: T[], fc?: CompareFunction | null, fm?: MapFunction | null): boolean; /** * Find first index of an unsorted value. * @param x an array * @param fc compare function (a, b) * @param fm map function (v, i, x) * @returns index of first unsorted value, -1 if sorted */ export declare function searchUnsortedValue(x: T[], fc?: CompareFunction | null, fm?: MapFunction | null): number; /** * Arrange values in order. * @param x an array * @param fc compare function (a, b) * @param fm map function (v, i, x) * @param fs swap function (x, i, j) * @returns x' | x' = x; x'[i] ≤ x'[j] ∀ i ≤ j */ export declare function sort(x: T[], fc?: CompareFunction | null, fm?: MapFunction | null, fs?: SwapFunction | null): T[]; export { sort as toSorted }; /** * Arrange values in order! * @param x an array (updated!) * @param fc compare function (a, b) * @param fm map function (v, i, x) * @param fs swap function (x, i, j) * @returns x | x[i] ≤ x[j] ∀ i ≤ j */ export declare function sort$(x: T[], fc?: CompareFunction | null, fm?: MapFunction | null, fs?: SwapFunction | null): T[]; /** * Arrange a range of values in order. * @param x an array * @param i begin index * @param I end index (exclusive) * @param fc compare function (a, b) * @param fm map function (v, i, x) * @param fs swap function (x, i, j) * @returns x' | x' = x; x'[i] ≤ x'[j] ∀ i ≤ j */ export declare function rangedSort(x: T[], i: number, I: number, fc?: CompareFunction | null, fm?: MapFunction | null, fs?: SwapFunction | null): T[]; /** * Arrange a range of values in order! * @param x an array (updated!) * @param i begin index * @param I end index (exclusive) * @param fc compare function (a, b) * @param fm map function (v, i, x) * @param fs swap function (x, i, j) * @returns x | x[i] ≤ x[j] ∀ i ≤ j */ export declare function rangedSort$(x: T[], i: number, I: number, fc?: CompareFunction | null, fm?: MapFunction | null, fs?: SwapFunction | null): T[]; /** * Partially arrange values in order. * @param x an array * @param n minimum number of values to sort * @param fc compare function (a, b) * @param fm map function (v, i, x) * @param fs swap function (x, i, j) * @returns x' | x' = x; x'[i] ≤ x'[j] ∀ i ≤ j */ export declare function partialSort(x: T[], n: number, fc?: CompareFunction | null, fm?: MapFunction | null, fs?: SwapFunction | null): T[]; /** * Partially arrange values in order! * @param x an array (updated!) * @param n minimum number of values to sort * @param fc compare function (a, b) * @param fm map function (v, i, x) * @param fs swap function (x, i, j) * @returns x | x[i] ≤ x[j] ∀ i ≤ j */ export declare function partialSort$(x: T[], n: number, fc?: CompareFunction | null, fm?: MapFunction | null, fs?: SwapFunction | null): T[]; /** * Partially arrange a range of values in order. * @param x an array * @param i begin index * @param I end index (exclusive) * @param n minimum number of values to sort * @param fc compare function (a, b) * @param fm map function (v, i, x) * @param fs swap function (x, i, j) * @returns x' | x' = x; x'[i] ≤ x'[j] ∀ i ≤ j */ export declare function rangedPartialSort(x: T[], i: number, I: number, n: number, fc?: CompareFunction | null, fm?: MapFunction | null, fs?: SwapFunction | null): T[]; /** * Partially arrange a range of values in order! * @param x an array (updated!) * @param i begin index * @param I end index (exclusive) * @param n minimum number of values to sort * @param fc compare function (a, b) * @param fm map function (v, i, x) * @param fs swap function (x, i, j) * @returns x | x[i] ≤ x[j] ∀ i ≤ j */ export declare function rangedPartialSort$(x: T[], i: number, I: number, n: number, fc?: CompareFunction | null, fm?: MapFunction | null, fs?: SwapFunction | null): T[]; /** * Find first smallest value. * @param x an array * @param fc compare function (a, b) * @param fm map function (v, i, x) * @returns v | v ≤ vᵢ; vᵢ ∈ x */ export declare function minimum(x: T[], fc?: CompareFunction | null, fm?: MapFunction | null): T; export { minimum as min }; /** * Find first smallest entry. * @param x an array * @param fc compare function (a, b) * @param fm map function (v, i, x) * @returns [min_index, min_value] */ export declare function minimumEntry(x: T[], fc?: CompareFunction | null, fm?: MapFunction | null): [number, T]; export { minimumEntry as minEntry }; /** * Find first largest value. * @param x an array * @param fc compare function (a, b) * @param fm map function (v, i, x) * @returns v | v ≥ vᵢ; vᵢ ∈ x */ export declare function maximum(x: T[], fc?: CompareFunction | null, fm?: MapFunction | null): T; export { maximum as max }; /** * Find first largest entry. * @param x an array * @param fc compare function (a, b) * @param fm map function (v, i, x) * @returns [max_index, max_value] */ export declare function maximumEntry(x: T[], fc?: CompareFunction | null, fm?: MapFunction | null): [number, T]; export { maximumEntry as maxEntry }; /** * Find smallest and largest values. * @param x an array * @param fc compare function (a, b) * @param fm map function (v, i, x) * @returns [min_value, max_value] */ export declare function range(x: T[], fc?: CompareFunction | null, fm?: MapFunction | null): [T | undefined, T | undefined]; /** * Find smallest and largest entries. * @param x an array * @param fc compare function (a, b) * @param fm map function (v, i, x) * @returns [min_entry, max_entry] */ export declare function rangeEntries(x: T[], fc?: CompareFunction | null, fm?: MapFunction | null): [[number, T | undefined], [number, T | undefined]]; /** * Find smallest values. * @param x an array * @param n number of values * @param fc compare function (a, b) * @param fm map function (v, i, x) * @returns n smallest values in ascending order */ export declare function minimums(x: T[], n: number, fc?: CompareFunction | null, fm?: MapFunction | null): T[]; /** * Find smallest entries. * @param x an array * @param n number of values * @param fc compare function (a, b) * @param fm map function (v, i, x) * @returns n smallest entries in ascending order */ export declare function minimumEntries(x: T[], n: number, fc?: CompareFunction | null, fm?: MapFunction | null): [number, T][]; /** * Find largest values. * @param x an array * @param n number of values * @param fc compare function (a, b) * @param fm map function (v, i, x) * @returns n largest values in descending order */ export declare function maximums(x: T[], n: number, fc?: CompareFunction | null, fm?: MapFunction | null): T[]; /** * Find largest entries. * @param x an array * @param n number of values * @param fc compare function (a, b) * @param fm map function (v, i, x) * @returns n largest entries in descending order */ export declare function maximumEntries(x: T[], n: number, fc?: CompareFunction | null, fm?: MapFunction | null): [number, T][]; /** * Find first index of minimum value. * @param x an array * @param fc compare function (a, b) * @param fm map function (v, i, x) * @returns first index of minimum value, -1 if empty */ export declare function searchMinimumValue(x: T[], fc?: CompareFunction | null, fm?: MapFunction | null): number; /** * Find first index of maximum value. * @param x an array * @param fc compare function (a, b) * @param fm map function (v, i, x) * @returns first index of maximum value, -1 if empty */ export declare function searchMaximumValue(x: T[], fc?: CompareFunction | null, fm?: MapFunction | null): number; /** * Find indices of minimum values. * @param x an array * @param n number of values * @param fc compare function (a, b) * @param fm map function (v, i, x) * @returns indices of minimum values in ascending order */ export declare function searchMinimumValues(x: T[], n: number, fc?: CompareFunction | null, fm?: MapFunction | null): number[]; /** * Find indices of maximum values. * @param x an array * @param n number of values * @param fc compare function (a, b) * @param fm map function (v, i, x) * @returns indices of maximum values in descending order */ export declare function searchMaximumValues(x: T[], n: number, fc?: CompareFunction | null, fm?: MapFunction | null): number[]; /** * Examine if two arrays are equal. * @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 isEqual(x: T[], y: T[], fc?: CompareFunction | null, fm?: MapFunction | null): boolean; /** * Compare two arrays (lexicographically). * @param x an array * @param y another array * @param fc compare function (a, b) * @param fm map function (v, i, x) * @returns xy: +ve */ export declare function compare(x: T[], y: T[], fc?: CompareFunction | null, fm?: MapFunction | null): number; /** * Get first value. * @param x an array * @param vd default value * @returns x[0] || vd */ export declare function head(x: T[], vd?: T): T | undefined; export { head as front }; export { head as first }; /** * Get values except first. * @param x an array * @returns x[1..|x|] */ export declare function tail(x: T[]): T[]; /** * Get values except last. * @param x an array * @returns x[0..|x|-1] */ export declare function init(x: T[]): T[]; /** * Get last value. * @param x an array * @param vd default value * @returns x[|x|-1] || vd */ export declare function last(x: T[], vd?: T): T | undefined; export { last as back }; /** * Get values from middle. * @param x an array * @param i begin index * @param n number of values [1] * @returns x[i..i+n] */ export declare function middle(x: T[], i: number, n?: number): T[]; /** * Get part of an array. * @param x an array * @param i begin index [0] * @param I end index [|x|] * @returns x[i..I] */ export declare function slice(x: T[], i?: number, I?: number): T[]; /** * Get part of an array! * @param x an array (updated!) * @param i begin index [0] * @param I end index [|x|] * @returns x = x[i..I] */ export declare function slice$(x: T[], i?: number, I?: number): T[]; /** * Check if array has a value. * @param x an array * @param v search value * @param i begin index [0] * @returns v ∈ x[i..]? */ export declare function includes(x: T[], v: T, i?: number): boolean; /** * Examine if array has a value. * @param x an array * @param v search value * @param fc compare function (a, b) * @param fm map function (v, i, x) * @returns v ∈ x? */ export declare function hasValue(x: T[], v: T, fc?: CompareFunction | null, fm?: MapFunction | null): boolean; /** * Find first index of a value. * @param x an array * @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(x: T[], v: T, fc?: CompareFunction | null, fm?: MapFunction | null): number; /** * Find last index of a value. * @param x an array * @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(x: T[], v: T, fc?: CompareFunction | null, fm?: MapFunction | null): number; /** * Find indices of value. * @param x an array * @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(x: T[], v: T, fc?: CompareFunction | null, fm?: MapFunction | null): number[]; /** * Find first index of an adjacent duplicate value. * @param x an array * @param fc compare function (a, b) * @param fm map function (v, i, x) * @returns index of first adjacent duplicate value, -1 if none */ export declare function searchAdjacentDuplicateValue(x: T[], fc?: CompareFunction | null, fm?: MapFunction | null): number; export { searchAdjacentDuplicateValue as searchAdjacentDuplicate }; /** * Find first index where two arrays differ. * @param x an array * @param y another array * @param fc compare function (a, b) * @param fm map function (v, i, x) * @returns first index where x[i] ≠ y[i], or -1 */ export declare function searchMismatchedValue(x: T[], y: T[], fc?: CompareFunction | null, fm?: MapFunction | null): number; export { searchMismatchedValue as searchMismatch }; /** * Examine if array starts with a prefix. * @param x an array * @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(x: T[], y: T[], fc?: CompareFunction | null, fm?: MapFunction | null): boolean; export { hasPrefix as startsWith }; /** * Examine if array ends with a suffix. * @param x an array * @param y search suffix * @param fc compare function (a, b) * @param fm map function (v, i, x) * @returns x[|x|-|y|..] = y? */ export declare function hasSuffix(x: T[], y: T[], fc?: CompareFunction | null, fm?: MapFunction | null): boolean; export { hasSuffix as endsWith }; /** * Examine if array contains an infix. * @param x an array * @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(x: T[], y: T[], fc?: CompareFunction | null, fm?: MapFunction | null): boolean; /** * Examine if array has a subsequence. * @param x an array * @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(x: T[], y: T[], fc?: CompareFunction | null, fm?: MapFunction | null): boolean; /** * Examine if array has a permutation. * @param x an array * @param y search permutation * @param fc map function (v, i, x) * @param fm compare function (a, b) * @returns x contains a shuffled version of y? */ export declare function hasPermutation(x: T[], y: T[], fc?: CompareFunction | null, fm?: MapFunction | null): boolean; /** * Obtain all possible prefixes. * @param x an array * @param n number of values [-1 ⇒ any] * @returns [[], x[..1], x[..2], ...] if n<0; [x[..n]] otherwise */ export declare function prefixes(x: T[], n?: number): T[][]; /** * List all possible prefixes. * @param x an array * @param n number of values [-1 ⇒ any] * @returns [], x[..1], x[..2], ... if n<0; x[..n] otherwise */ export declare function iprefixes(x: T[], n?: number): IterableIterator; /** * Obtain all possible suffixes. * @param x an array * @param n number of values [-1 ⇒ any] * @returns [x[0..], x[1..], x[2..], ...] if n<0; [x[-n..]] otherwise */ export declare function suffixes(x: T[], n?: number): T[][]; /** * List all possible suffixes. * @param x an array * @param n number of values [-1 ⇒ any] * @returns x[0..], x[1..], x[2..], ... if n<0; x[-n..] otherwise */ export declare function isuffixes(x: T[], n?: number): IterableIterator; /** * Obtain all possible infixes. * @param x an array * @param n number of values [-1 ⇒ any] * @returns [[], x[0..1], x[0..2], ..., x[1..2], ...] if n<0; [only of length n] otherwise */ export declare function infixes(x: T[], n?: number): T[][]; /** * List all possible infixes. * @param x an array * @param n number of values [-1 ⇒ any] * @returns [], x[0..1], x[0..2], ..., x[1..2], ... if n<0; only of length n otherwise */ export declare function iinfixes(x: T[], n?: number): IterableIterator; /** * Obtain all possible subsequences. * @param x an array * @param n number of values [-1 ⇒ any] * @returns [elements selected by bit from 0..2^|x|] if n<0; [only of length n] otherwise */ export declare function subsequences(x: T[], n?: number): T[][]; /** * List all possible subsequences. * @param x an array * @param n number of values [-1 ⇒ any] * @returns elements selected by bit from 0..2^|x| if n<0; only of length n otherwise */ export declare function isubsequences(x: T[], n?: number): IterableIterator; /** * Obtain all possible permutations. * @param x an array * @param n number of values [-1 ⇒ any] * @returns [[], arrangements of length 1, of length 2, ...] if n<0; [only of length n] otherwise */ export declare function permutations(x: T[], n?: number): T[][]; /** * List all possible permutations. * @param x an array * @param n number of values [-1 ⇒ any] * @returns [], arrangements of length 1, of length 2, ... if n<0; only of length n otherwise */ export declare function ipermutations(x: T[], n?: number): IterableIterator; /** * Find first index of an infix. * @param x an array * @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(x: T[], y: T[], fc?: CompareFunction | null, fm?: MapFunction | null): number; /** * Find last index of an infix. * @param x an array * @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(x: T[], y: T[], fc?: CompareFunction | null, fm?: MapFunction | null): number; /** * Find indices of an infix. * @param x an array * @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(x: T[], y: T[], fc?: CompareFunction | null, fm?: MapFunction | null): number[]; /** * Find first index of a subsequence. * @param x an array * @param y search subsequence * @param fc compare function (a, b) * @param fm map function (v, i, x) * @returns begin index of subsequence, -1 if not found */ export declare function searchSubsequence(x: T[], y: T[], fc?: CompareFunction | null, fm?: MapFunction | null): number; /** * Pick an arbitrary value. * @param x an array * @param fr random number generator ([0, 1)) * @returns x[i] | i ∈ 0..|x| */ export declare function randomValue(x: T[], fr?: ReadFunction | null): T; export { randomValue as value }; /** * Pick an arbitrary prefix. * @param x an array * @param n number of values [-1 ⇒ any] * @param fr random number generator ([0, 1)) * @returns x[..i] if n<0; x[..n] otherwise | i ∈ 0..|x| */ export declare function randomPrefix(x: T[], n?: number, fr?: ReadFunction | null): T[] | null; export { randomPrefix as prefix }; /** * Pick an arbitrary suffix. * @param x an array * @param n number of values [-1 ⇒ any] * @param fr random number generator ([0, 1)) * @returns x[|x|-i..] if n<0; x[|x|-n..] otherwise | i ∈ 0..|x| */ export declare function randomSuffix(x: T[], n?: number, fr?: ReadFunction | null): T[] | null; export { randomSuffix as suffix }; /** * Pick an arbitrary infix. * @param x an array * @param n number of values [-1 ⇒ any] * @param fr random number generator ([0, 1)) * @returns x[i..j] if n<0; x[i..i+n] otherwise | i, j ∈ 0..|x| */ export declare function randomInfix(x: T[], n?: number, fr?: ReadFunction | null): T[] | null; export { randomInfix as infix }; /** * Pick an arbitrary subsequence. * @param x an array * @param n number of values [-1 ⇒ any] * @param fr random number generator ([0, 1)) * @returns x[i, j, ...] | [i, j, ...] = is; |is| = |x| if n<0 else n */ export declare function randomSubsequence(x: T[], n?: number, fr?: ReadFunction | null): T[] | null; export { randomSubsequence as subsequence }; /** * Pick an arbitrary permutation. * @param x an array * @param n number of values [-1 ⇒ any] * @param fr random number generator ([0, 1)) * @returns x' | x' = x; values are randomly shuffled */ export declare function randomPermutation(x: T[], n?: number, fr?: ReadFunction | null): T[] | null; export { randomPermutation as permutation }; /** * Pick an arbitrary permutation! * @param x an array (updated!) * @param n number of values [-1 ⇒ any] * @param fr random number generator ([0, 1)) * @returns x | values are randomly shuffled */ export declare function randomPermutation$(x: T[], n?: number, fr?: ReadFunction | null): T[]; export { randomPermutation$ as permutation$ }; export { randomPermutation$ as permute$ }; export { randomPermutation$ as shuffle$ }; /** * Find first value passing a test. * @param x an array * @param ft test function (v, i, x) * @returns first v | ft(v) = true; v ∈ x */ export declare function find(x: T[], ft: TestFunction): T; /** * Find last value passing a test. * @param x an array * @param ft test function (v, i, x) * @returns last v | ft(v) = true; v ∈ x */ export declare function findRight(x: T[], ft: TestFunction): T; /** * Keep first n values only. * @param x an array * @param n number of values [1] * @returns x[0..n] */ export declare function take(x: T[], n?: number): T[]; export { take as left }; /** * Keep last n values only. * @param x an array * @param n number of values [1] * @returns x[0..n] */ export declare function takeRight(x: T[], n?: number): T[]; export { takeRight as right }; /** * Keep values from left, while a test passes. * @param x an array * @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(x: T[], ft: TestFunction): T[]; /** * Keep values from right, while a test passes. * @param x an array * @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(x: T[], ft: TestFunction): T[]; /** * Discard first n values only. * @param x an array * @param n number of values [1] * @returns x[n..] */ export declare function drop(x: T[], n?: number): T[]; /** * Discard last n values only. * @param x an array * @param n number of values [1] * @returns x[0..-n] */ export declare function dropRight(x: T[], n?: number): T[]; /** * Discard values from left, while a test passes. * @param x an array * @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(x: T[], ft: TestFunction): T[]; /** * Discard values from right, while a test passes. * @param x an array * @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(x: T[], ft: TestFunction): T[]; /** * 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(x: T[], ft: TestFunction): number; /** * Scan from right, while a test passes. * @param x an array * @param ft test function (v, i, x) * @returns first index where test passes till end */ export declare function scanWhileRight(x: T[], ft: TestFunction): 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(x: T[], ft: TestFunction): number; /** * Scan from right, until a test passes. * @param x an array * @param ft test function (v, i, x) * @returns first index where test fails till end */ export declare function scanUntilRight(x: T[], ft: TestFunction): number; /** * Find first index of a value. * @param x an array * @param v search value * @param i begin index [0] * @returns index of v in x[i..] if found else -1 */ export declare function indexOf(x: T[], v: T, i?: number): number; /** * Find last index of a value. * @param x an array * @param v search value * @param i begin index [|x|-1] * @returns last index of v in x[0..i] if found else -1 */ export declare function lastIndexOf(x: T[], v: T, i?: number): number; /** * Find index of first value passing a test. * @param x an array * @param ft test function (v, i, x) * @returns first index of value, -1 if not found */ export declare function search(x: T[], ft: TestFunction): number; export { search as findIndex }; /** * Find index of last value passing a test. * @param x an array * @param ft test function (v, i, x) * @returns last index of value, -1 if not found */ export declare function searchRight(x: T[], ft: TestFunction): number; export { searchRight as findLastIndex }; /** * Find indices of values passing a test. * @param x an array * @param ft test function (v, i, x) * @returns indices of value */ export declare function searchAll(x: T[], ft: TestFunction): number[]; /** * Call a function for each value. * @param x an array * @param fp process function (v, i, x) */ export declare function forEach(x: T[], fp: ProcessFunction): void; /** * Examine if any value satisfies a test. * @param x an array * @param ft test function (v, i, x) * @returns true if ft(vᵢ) = true for some vᵢ ∈ x */ export declare function some(x: T[], ft?: TestFunction | null): boolean; export { some as anyOf }; /** * Examine if all values satisfy a test. * @param x an array * @param ft test function (v, i, x) * @returns true if ft(vᵢ) = true for all vᵢ ∈ x */ export declare function every(x: T[], ft?: TestFunction | null): boolean; export { every as allOf }; /** * Transform values of an array. * @param x an array * @param fm map function (v, i, x) * @returns [fm(v₀), fm(v₁), ...] | vᵢ ∈ x */ export declare function map(x: T[], fm: MapFunction): (T | U)[]; /** * Transform values of an array! * @param x an array (updated!) * @param fm map function (v, i, x) * @returns x = [fm(v₀), fm(v₁), ...]; vᵢ ∈ x */ export declare function map$(x: T[], fm: MapFunction): T[]; /** * Reduce values of array to a single value. * @param x an array * @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(x: T[], fr: ReduceFunction, acc?: T | U): T | U; /** * Reduce values from right, to a single value. * @param x an array * @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 reduceRight(x: T[], fr: ReduceFunction, acc?: T | U): T | U; /** * Keep values which pass a test. * @param x an array * @param ft test function (v, i, x) * @returns [v₀, v₁, ...] | ft(vᵢ) = true; vᵢ ∈ x */ export declare function filter(x: T[], ft: TestFunction): T[]; export { filter as findAll }; /** * Keep values which pass a test! * @param x an array (updated!) * @param ft test function (v, i, x) * @returns x = [v₀, v₁, ...] | ft(vᵢ) = true; vᵢ ∈ x */ export declare function filter$(x: T[], ft: TestFunction): T[]; /** * Keep values at given indices. * @param x an array * @param is indices * @returns v₀, v₁, ... | vᵢ = x[i]; i ∈ is */ export declare function filterAt(x: T[], is: number[]): T[]; /** * Discard values which pass a test. * @param x an array * @param ft test function (v, i, x) * @returns [v₀, v₁, ...] | ft(vᵢ) = false; vᵢ ∈ x */ export declare function reject(x: T[], ft: TestFunction): T[]; /** * Discard values which pass a test! * @param x an array (updated!) * @param ft test function (v, i, x) * @returns x = [v₀, v₁, ...] | ft(vᵢ) = false; vᵢ ∈ x */ export declare function reject$(x: T[], ft: TestFunction): T[]; /** * Discard values at given indices. * @param x an array * @param is indices * @returns [v₀, v₁, ...] | vᵢ = x[i]; i ∉ is */ export declare function rejectAt(x: T[], is: number[]): T[]; /** * Flatten nested array to given depth. * @param x a nested array * @param n maximum depth [-1 ⇒ all] * @param fm map function (v, i, x) * @param ft flatten test function (v, i, x) [is] * @returns flat iterable */ export declare function flat(x: unknown[], n?: number, fm?: MapFunction | null, ft?: TestFunction | null): unknown[]; /** * Flatten nested array, based on map function. * @param x an array * @param fm map function (v, i, x) * @param ft flatten test function (v, i, x) [is] * @returns flat iterable */ export declare function flatMap(x: unknown[], fm?: MapFunction | null, ft?: TestFunction | null): unknown[]; /** * Perform exclusive prefix scan from left to right. * @param x an array * @param fr reduce function (acc, v, i, x) * @param acc initial value * @returns [acc, fr(acc, v₀), fr(fr(acc, v₀), v₁)...] */ export declare function exclusiveScan(x: T[], fr: ReduceFunction, acc: T | U): (T | U)[]; /** * Perform exclusive prefix scan from left to right! * @param x an array (updated!) * @param fr reduce function (acc, v, i, x) * @param acc initial value * @returns x = [acc, fr(acc, v₀), fr(fr(acc, v₀), v₁)...] */ export declare function exclusiveScan$(x: T[], fr: ReduceFunction, acc: T): T[]; /** * Perform inclusive prefix scan from left to right. * @param x an array * @param fr reduce function (acc, v, i, x) * @param acc initial value * @returns [fr(acc, v₀), fr(fr(acc, v₀), v₁)...] */ export declare function inclusiveScan(x: T[], fr: ReduceFunction, acc?: T | U): (T | U)[]; export { inclusiveScan as accumulate }; /** * Perform inclusive prefix scan from left to right! * @param x an array (updated!) * @param fr reduce function (acc, v, i, x) * @param acc initial value * @returns x = [fr(acc, v₀), fr(fr(acc, v₀), v₁)...] */ export declare function inclusiveScan$(x: T[], fr: ReduceFunction, acc: T): T[]; /** * Combine adjacent values of an array. * @param x an array * @param fc combine function (u, v) * @param acc initial value * @returns [fc(acc, v₀), fc(v₀, v₁)...] | vᵢ ∈ x */ export declare function adjacentCombine(x: T[], fc: CombineFunction, acc: T): T[]; /** * Combine adjacent values of an array! * @param x an array (updated!) * @param fc combine function (u, v) * @param acc initial value * @returns x = [fc(acc, v₀), fc(v₀, v₁)...] | vᵢ ∈ x */ export declare function adjacentCombine$(x: T[], fc: CombineFunction, acc: T): T[]; /** * Place a separator between every value. * @param x an array * @param v separator * @returns [x[0], v, x[1], v, ..., x[|x|-1]] */ export declare function intersperse(x: T[], v: T): T[]; /** * Estimate new values between existing ones. * @param x an array * @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(x: T[], fc: CombineFunction): T[]; /** * Place values of an array between another. * @param x an array * @param y another array * @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(x: T[], y: T[], m?: number, n?: number, s?: number, t?: number): T[]; /** * Place values from iterables alternately. * @param xs arrays * @returns [x₀[0], x₁[0], ..., x₀[1], x₁[0], ...] | [x₀, x₁, ...] = xs */ export declare function interleave(xs: T[][]): T[]; /** * Combine values from arrays. * @param xs arrays * @param fm map function (vs, i) * @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(xs: T[][], fm?: MapFunction | null, fe?: EndFunction | null, vd?: T): (T[] | U)[]; /** * Fill with given value. * @param x an array * @param v value * @param i begin index [0] * @param I end index [|x|] * @returns x' | x' = x; x'[i..I] = v */ export declare function fill(x: T[], v: T, i?: number, I?: number): T[]; /** * Fill with given value! * @param x an array (updated!) * @param v value * @param i begin index [0] * @param I end index [|x|] * @returns x | x[i..I] = v */ export declare function fill$(x: T[], v: T, i?: number, I?: number): T[]; /** * Add value to the end. * @param x an array * @param vs values to add * @returns x ⧺ vs */ export declare function push(x: T[], ...vs: T[]): T[]; export { push as pushBack }; export { push as append }; /** * Add values to the end! * @param x an array (updated!) * @param vs values to add * @returns x = x ⧺ vs */ export declare function push$(x: T[], ...vs: T[]): T[]; export { push$ as pushBack$ }; export { push$ as append$ }; /** * Remove last value. * @param x an array * @returns x[0..|x|-1] */ export declare function pop(x: T[]): T[]; export { pop as popBack }; /** * Remove last value! * @param x an array (updated!) * @returns x = x[0..|x|-1] */ export declare function pop$(x: T[]): T[]; export { pop as popBack$ }; /** * Remove first value. * @param x an array * @returns x[1..] */ export declare function shift(x: T[]): T[]; export { shift as popFront }; /** * Remove first value! * @param x an array (updated!) * @returns x = x[1..] */ export declare function shift$(x: T[]): T[]; export { shift$ as popFront$ }; /** * Add values to the start. * @param x an array * @param vs values to add * @returns vs ⧺ x */ export declare function unshift(x: Iterable, ...vs: T[]): T[]; export { unshift as pushFront }; export { unshift as prepend }; /** * Add values to the start! * @param x an array (updated!) * @param vs values to add * @returns x = vs ⧺ x */ export declare function unshift$(x: T[], ...vs: T[]): T[]; export { unshift$ as pushFront$ }; export { unshift$ as prepend$ }; /** * Copy part of array to another. * @param x target array * @param y source array * @param j write index [0] * @param i read begin index [0] * @param I read end index [|x|] * @returns x[0..j] ⧺ y[i..I] ⧺ x[j+I-i..] */ export declare function copy(x: T[], y: T[], j?: number, i?: number, I?: number): T[]; /** * Copy part of array to another! * @param x target array (updated!) * @param y source array * @param j write index [0] * @param i read begin index [0] * @param I read end index [|x|] * @returns x = x[0..j] ⧺ y[i..I] ⧺ x[j+I-i..] */ export declare function copy$(x: T[], y: T[], j?: number, i?: number, I?: number): T[]; /** * Copy part of array within. * @param x an array * @param j write index [0] * @param i read begin index [0] * @param I read end index [|x|] * @returns x[0..j] ⧺ x[i..I] ⧺ x[j+I-i..] */ export declare function copyWithin(x: T[], j?: number, i?: number, I?: number): T[]; /** * Copy part of array within! * @param x an array (updated!) * @param j write index [0] * @param i read begin index [0] * @param I read end index [|x|] * @returns x = x[0..j] ⧺ x[i..I] ⧺ x[j+I-i..] */ export declare function copyWithin$(x: T[], j?: number, i?: number, I?: number): T[]; /** * Move part of array within. * @param x an array * @param j write index [0] * @param i read begin index [0] * @param I read end index [|x|] * @returns x[0..j] ⧺ x[i..I] ⧺ x[j..i] ⧺ x[I..] */ export declare function moveWithin(x: T[], j?: number, i?: number, I?: number): T[]; /** * Move part of array within! * @param x an array (updated!) * @param j write ±index [0] * @param i read begin ±index [0] * @param I read end ±index [|x|] * @returns x = x[0..j] ⧺ x[i..I] ⧺ x[j..i] ⧺ x[I..] */ export declare function moveWithin$(x: T[], j?: number, i?: number, I?: number): T[]; /** * Remove or replace existing values. * @param x an array * @param i remove ±index * @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(x: T[], i: number, n?: number, ...vs: T[]): T[]; export { splice as toSpliced }; /** * Remove or replace existing values! * @param x an array (updated!) * @param i remove ±index * @param n number of values to remove [rest] * @param vs values to insert * @returns x = x[0..i] ⧺ vs ⧺ x[i+n..] */ export declare function splice$(x: T[], i: number, n?: number, ...vs: T[]): T[]; /** * Count values which satisfy a test. * @param x an array * @param ft test function (v, i, x) * @returns Σtᵢ | tᵢ = 1 if ft(vᵢ) else 0; vᵢ ∈ x */ export declare function count(x: T[], ft: TestFunction): number; /** * Count occurrences of each distinct value. * @param x an array * @param fm map function (v, i, x) * @returns Map \{value ⇒ count\} */ export declare function countEach(x: T[], fm?: MapFunction | null): Map; export { countEach as countAs }; /** * Segregate values by test result. * @param x an array * @param ft test function (v, i, x) * @returns [satisfies, doesnt] */ export declare function partition(x: T[], ft: TestFunction): [T[], T[]]; /** * Segregate each distinct value. * @param x an array * @param fm map function (v, i, x) * @returns Map \{key ⇒ values\} */ export declare function partitionEach(x: T[], fm?: MapFunction | null): Map; export { partitionEach as groupToMap }; export { partitionEach as partitionAs }; /** * Break array considering test as separator. * @param x an array * @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(x: T[], ft: TestFunction): T[][]; /** * Break array considering indices as separator. * @param x an array * @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(x: T[], is: number[]): T[][]; /** * Break array when test passes. * @param x an array * @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(x: T[], ft: TestFunction): T[][]; /** * Break array after test passes. * @param x an array * @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(x: T[], ft: TestFunction): T[][]; /** * Break array at given indices. * @param x an array * @param is split ±indices (left to right) * @returns [x[0..j], x[j..k], ...] | ft(x[i]) = true; i = j, k, ...; i ∈ is */ export declare function cutAt(x: T[], is: number[]): T[][]; /** * Break array after given indices. * @param x an array * @param is split ±indices (left to right) * @returns [x[0..j+1], x[j+1..k], ...] | ft(x[i]) = true; i = j, k, ...; i ∈ is */ export declare function cutAtRight(x: T[], is: number[]): T[][]; /** * Keep similar values together and in order. * @param x an array * @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(x: T[], fc?: CompareFunction | null, fm?: MapFunction | null): T[][]; /** * Break array into chunks of given size. * @param x an array * @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(x: T[], n?: number, s?: number): T[][]; /** * Append values from arrays. * @param xs arrays * @returns x₀ ⧺ x₁ ⧺ ... | [x₀, x₁, ...] = xs */ export declare function concat(...xs: T[][]): T[]; /** * Append values from arrays! * @param x an array (updated!) * @param ys arrays to append * @returns x = x ⧺ y₀ ⧺ y₁ ⧺ ...] | [y₀, y₁, ...] = ys */ export declare function concat$(x: T[], ...ys: Iterable[]): T[]; /** * Join values together into a string. * @param x an array * @param sep separator [,] * @returns "$\{v₀\}$\{sep\}$\{v₁\}..." | vᵢ ∈ x */ export declare function join(x: T[], sep?: string): string; /** * Obtain values that cycle through array. * @param x an array * @param i begin ±index [0] * @param n number of values [|x|] */ export declare function cycle(x: T[], i?: number, n?: number): T[]; /** * Repeat an array given times. * @param x an array * @param n times [1] * @returns x ⧺ x ⧺ ...(n times) */ export declare function repeat(x: T[], n?: number): T[]; /** * Reverse the values. * @param x an array * @returns [x[|x|-1], x[|x|-2], ..., x[1], x[0]] */ export declare function reverse(x: T[]): T[]; export { reverse as toReversed }; /** * Reverse the values! * @param x an array (updated!) * @returns x = [x[|x|-1], x[|x|-2], ..., x[1], x[0]] */ export declare function reverse$(x: T[]): T[]; /** * Rotate values in array. * @param x an array * @param n rotate amount (+ve: left, -ve: right) [0] * @returns x[n..] ⧺ x[0..n] */ export declare function rotate(x: T[], n?: number): T[]; /** * Rotate values in array! * @param x an array (updated!) * @param n rotate amount (+ve: left, -ve: right) [0] * @returns x = x[n..] ⧺ x[0..n] */ export declare function rotate$(x: T[], n?: number): T[]; /** * Examine 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(x: T[], fc?: CompareFunction | null, fm?: MapFunction | null): boolean; /** * Examine 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(x: T[], y: T[], fc?: CompareFunction | null, fm?: MapFunction | null): boolean; /** * Remove duplicate values. * @param x an array * @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(x: T[], fc?: CompareFunction | null, fm?: MapFunction | null): T[]; /** * Obtain values present in any array. * @param x an array * @param y another array * @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(x: T[], y: T[], fc?: CompareFunction | null, fm?: MapFunction | null): T[]; /** * Obtain values present in any array! * @param x an array (updated!) * @param y another array * @param fc compare function (a, b) * @param fm map function (v, i, x) * @returns x = x ∪ y = \{v | v ∈ x or v ∈ y\} */ export declare function union$(x: T[], y: T[], fc?: CompareFunction | null, fm?: MapFunction | null): T[]; /** * Obtain values present in both arrays. * @param x an array * @param y another array * @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(x: T[], y: T[], fc?: CompareFunction | null, fm?: MapFunction | null): T[]; /** * Obtain values not present in another array. * @param x an array * @param y another array * @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(x: T[], y: T[], fc?: CompareFunction | null, fm?: MapFunction | null): T[]; /** * Obtain values not present in both arrays. * @param x an array * @param y another array * @param fc compare function (a, b) * @param fm map function (v, i, x) * @returns x-y ∪ y-x */ export declare function symmetricDifference(x: T[], y: T[], fc?: CompareFunction | null, fm?: MapFunction | null): T[]; /** * Obtain cartesian product of arrays. * @param xs arrays * @param fm map function (vs, i) * @returns x₀ × x₁ × ... = \{[v₀, v₁, ...] | v₀ ∈ x₀, v₁ ∈ x₁, ...] \} */ export declare function cartesianProduct(xs: T[][], fm?: MapFunction | null): (T[] | U)[];