/** Entries is an array of index-value pairs, with unique indices. */ export type Entries<T> = [number, T][];
/** IEntries is a list of index-value pairs, with unique indices. */ export type IEntries<T> = Iterable<[number, T]>;
/** Lists is a pair of index array and value array, with unique indices. */ export type Lists<T> = [number[], T[]];
/** ILists is a pair of index iterable list and value iterable list, with unique indices. */ export type ILists<T> = [Iterable<number>, Iterable<T>];
/**
 * 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 array.
 * @param v value in array
 * @param i index of value in array
 * @param x array containing the value
 */ export type ProcessFunction<T> = (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<T> = (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<T, U> = (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<T, U> = (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<T> = (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<T>(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<T>(fm: MapFunction<T, T>, 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<T>(x: Iterable<T>): 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$<T>(x: Iterable<T>): T[];
export { fromIterable$ as from$ };
/**
 * Shallow clone an array.
 * @param x an array
 * @returns shallow clone of x
 */ export declare function shallowClone<T>(x: T[]): T[];
export { shallowClone as clone };
/**
 * Deep clone an array.
 * @param x an array
 * @returns deep clone of x
 */ export declare function deepClone<T>(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<T>(x: T[]): number[];
/**
 * List all indices.
 * @param x an array
 * @returns 0, 1, ..., |x|-1
 */ export declare function ikeys<T>(x: T[]): IterableIterator<number>;
/**
 * Get all values.
 * @param x an array
 * @returns [v₀, v₁, ...] | vᵢ = x[i]
 */ export declare function values<T>(x: T[]): T[];
/**
 * List all values.
 * @param x an array
 * @returns v₀, v₁, ... | vᵢ = x[i]
 */ export declare function ivalues<T>(x: T[]): IterableIterator<T>;
/**
 * Obtain all index-value pairs.
 * @param x an array
 * @returns [[0, v₀], [1, v₁], ...] | vᵢ = x[i]
 */ export declare function entries<T>(x: T[]): Entries<T>;
/**
 * List all index-value pairs.
 * @param x an array
 * @returns [0, v₀], [1, v₁], ... | vᵢ = x[i]
 */ export declare function ientries<T>(x: T[]): IEntries<T>;
/**
 * 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<T>(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<T>(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<T>(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<T>(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$<T>(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$<T>(x: T[]): T[];
/**
 * Get value at index.
 * @param x an array
 * @param i index
 * @returns x[i]
 */ export declare function get<T>(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<T>(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<T>(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$<T>(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<T>(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$<T>(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<T>(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$<T>(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<T>(x: T[], i: number): T[];
/**
 * Remove value at index!
 * @param x an array (updated!)
 * @param i index
 * @returns x \\: [i]
 */ export declare function remove$<T>(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<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | 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<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | 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<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | 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<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null, fs?: SwapFunction<T> | 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$<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null, fs?: SwapFunction<T> | 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<T, U = T>(x: T[], i: number, I: number, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null, fs?: SwapFunction<T> | 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$<T, U = T>(x: T[], i: number, I: number, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null, fs?: SwapFunction<T> | 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<T, U = T>(x: T[], n: number, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null, fs?: SwapFunction<T> | 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$<T, U = T>(x: T[], n: number, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null, fs?: SwapFunction<T> | 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<T, U = T>(x: T[], i: number, I: number, n: number, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null, fs?: SwapFunction<T> | 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$<T, U = T>(x: T[], i: number, I: number, n: number, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null, fs?: SwapFunction<T> | 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<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | 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<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | 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<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | 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<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | 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<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | 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<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | 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<T, U = T>(x: T[], n: number, fc?: CompareFunction<number | T | U> | null, fm?: MapFunction<T, T | U> | 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<T, U = T>(x: T[], n: number, fc?: CompareFunction<number | T | U> | null, fm?: MapFunction<T, T | U> | 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<T, U = T>(x: T[], n: number, fc?: CompareFunction<number | T | U> | null, fm?: MapFunction<T, T | U> | 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<T, U = T>(x: T[], n: number, fc?: CompareFunction<number | T | U> | null, fm?: MapFunction<T, T | U> | 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<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | 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<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | 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<T, U = T>(x: T[], n: number, fc?: CompareFunction<number | T | U> | null, fm?: MapFunction<T, T | U> | 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<T, U = T>(x: T[], n: number, fc?: CompareFunction<number | T | U> | null, fm?: MapFunction<T, T | U> | 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<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | 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 x<y: -ve, x=y: 0, x>y: +ve
 */ export declare function compare<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): number;
/**
 * Get first value.
 * @param x an array
 * @param vd default value
 * @returns x[0] || vd
 */ export declare function head<T>(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<T>(x: T[]): T[];
/**
 * Get values except last.
 * @param x an array
 * @returns x[0..|x|-1]
 */ export declare function init<T>(x: T[]): T[];
/**
 * Get last value.
 * @param x an array
 * @param vd default value
 * @returns x[|x|-1] || vd
 */ export declare function last<T>(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<T>(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<T>(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$<T>(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<T>(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<T, U = T>(x: T[], v: T, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | 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<T, U = T>(x: T[], v: T, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | 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<T, U = T>(x: T[], v: T, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | 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<T, U = T>(x: T[], v: T, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | 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<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | 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<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | 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<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | 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<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | 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<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | 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<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | 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<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | 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<T>(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<T>(x: T[], n?: number): IterableIterator<T[]>;
/**
 * 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<T>(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<T>(x: T[], n?: number): IterableIterator<T[]>;
/**
 * 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<T>(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<T>(x: T[], n?: number): IterableIterator<T[]>;
/**
 * 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<T>(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<T>(x: T[], n?: number): IterableIterator<T[]>;
/**
 * 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<T>(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<T>(x: T[], n?: number): IterableIterator<T[]>;
/**
 * 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<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | 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<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | 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<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | 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<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | 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<T>(x: T[], fr?: ReadFunction<number> | 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<T>(x: T[], n?: number, fr?: ReadFunction<number> | 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<T>(x: T[], n?: number, fr?: ReadFunction<number> | 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<T>(x: T[], n?: number, fr?: ReadFunction<number> | 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<T>(x: T[], n?: number, fr?: ReadFunction<number> | 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<T>(x: T[], n?: number, fr?: ReadFunction<number> | 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$<T>(x: T[], n?: number, fr?: ReadFunction<number> | 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<T>(x: T[], ft: TestFunction<T>): 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<T>(x: T[], ft: TestFunction<T>): T;
/**
 * Keep first n values only.
 * @param x an array
 * @param n number of values [1]
 * @returns x[0..n]
 */ export declare function take<T>(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<T>(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<T>(x: T[], ft: TestFunction<T>): 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<T>(x: T[], ft: TestFunction<T>): T[];
/**
 * Discard first n values only.
 * @param x an array
 * @param n number of values [1]
 * @returns x[n..]
 */ export declare function drop<T>(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<T>(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<T>(x: T[], ft: TestFunction<T>): 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<T>(x: T[], ft: TestFunction<T>): 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<T>(x: T[], ft: TestFunction<T>): 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<T>(x: 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: T[], ft: TestFunction<T>): 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<T>(x: T[], ft: TestFunction<T>): 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<T>(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<T>(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<T>(x: T[], ft: TestFunction<T>): 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<T>(x: T[], ft: TestFunction<T>): 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<T>(x: T[], ft: TestFunction<T>): number[];
/**
 * Call a function for each value.
 * @param x an array
 * @param fp process function (v, i, x)
 */ export declare function forEach<T>(x: T[], fp: ProcessFunction<T>): 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<T>(x: T[], ft?: TestFunction<T> | 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<T>(x: T[], ft?: TestFunction<T> | 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<T, U = T>(x: T[], fm: MapFunction<T, T | U>): (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$<T>(x: T[], fm: MapFunction<T, T>): 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<T, U = T>(x: T[], fr: ReduceFunction<T, T | U>, 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<T, U = T>(x: T[], fr: ReduceFunction<T, T | U>, 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<T>(x: T[], ft: TestFunction<T>): 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$<T>(x: T[], ft: TestFunction<T>): 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<T>(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<T>(x: T[], ft: TestFunction<T>): 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$<T>(x: T[], ft: TestFunction<T>): 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<T>(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<unknown, unknown> | null, ft?: TestFunction<unknown> | 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<unknown, unknown> | null, ft?: TestFunction<unknown> | 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<T, U = T>(x: T[], fr: ReduceFunction<T, T | U>, 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$<T>(x: T[], fr: ReduceFunction<T, T>, 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<T, U = T>(x: T[], fr: ReduceFunction<T, T | U>, 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$<T>(x: T[], fr: ReduceFunction<T, T>, 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<T>(x: T[], fc: CombineFunction<T>, 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$<T>(x: T[], fc: CombineFunction<T>, 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<T>(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<T>(x: T[], fc: CombineFunction<T>): 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<T>(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<T>(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<T, U = T[]>(xs: T[][], fm?: MapFunction<T[], T[] | U> | 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<T>(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$<T>(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<T>(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$<T>(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<T>(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$<T>(x: T[]): T[];
export { pop as popBack$ };
/**
 * Remove first value.
 * @param x an array
 * @returns x[1..]
 */ export declare function shift<T>(x: T[]): T[];
export { shift as popFront };
/**
 * Remove first value!
 * @param x an array (updated!)
 * @returns x = x[1..]
 */ export declare function shift$<T>(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<T>(x: Iterable<T>, ...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$<T>(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<T>(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$<T>(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<T>(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$<T>(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<T>(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$<T>(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<T>(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$<T>(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<T>(x: T[], ft: TestFunction<T>): 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<T, U = T>(x: T[], fm?: MapFunction<T, T | U> | null): Map<T | U, number>;
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<T>(x: T[], ft: TestFunction<T>): [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<T, U = T>(x: T[], fm?: MapFunction<T, T | U> | null): Map<T | U, T[]>;
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<T>(x: T[], ft: TestFunction<T>): 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<T>(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<T>(x: T[], ft: TestFunction<T>): 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<T>(x: T[], ft: TestFunction<T>): 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<T>(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<T>(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<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | 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<T>(x: T[], n?: number, s?: number): T[][];
/**
 * Append values from arrays.
 * @param xs arrays
 * @returns x₀ ⧺ x₁ ⧺ ... | [x₀, x₁, ...] = xs
 */ export declare function concat<T>(...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$<T>(x: T[], ...ys: Iterable<T>[]): T[];
/**
 * Join values together into a string.
 * @param x an array
 * @param sep separator [,]
 * @returns "$\{v₀\}$\{sep\}$\{v₁\}..." | vᵢ ∈ x
 */ export declare function join<T>(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<T>(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<T>(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<T>(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$<T>(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<T>(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$<T>(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<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | 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<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | 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<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | 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<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | 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$<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | 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<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | 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<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | 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<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | 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<T, U = T>(xs: T[][], fm?: MapFunction<T[], T[] | U> | null): (T[] | U)[];