extra-array/index.d.ts

An array is a collection of values, stored contiguously.

/**
 * Entries is an array of index-value pairs, with unique indices.
 * [📘](https://github.com/nodef/extra-array/wiki/Entries)
 */
type Entries<T> = [number, T][];
/**
 * IEntries is a list of index-value pairs, with unique indices.
 * [📘](https://github.com/nodef/extra-array/wiki/IEntries)
 */
type IEntries<T> = Iterable<[number, T]>;
/**
 * Lists is a pair of index array and value array, with unique indices.
 * [📘](https://github.com/nodef/extra-array/wiki/Lists)
 */
type Lists<T> = [number[], T[]];
/**
 * ILists is a pair of index iterable list and value iterable list, with unique indices.
 * [📘](https://github.com/nodef/extra-array/wiki/ILists)
 */
type ILists<T> = [Iterable<number>, Iterable<T>];
/**
 * Handle reading of a single value.
 * [📘](https://github.com/nodef/extra-array/wiki/ReadFunction)
 * @returns value
 */
type ReadFunction<T> = () => T;
/**
 * Handle combining of two values.
 * [📘](https://github.com/nodef/extra-array/wiki/CombineFunction)
 * @param a a value
 * @param b another value
 * @returns combined value
 */
type CombineFunction<T> = (a: T, b: T) => T;
/**
 * Handle comparison of two values.
 * [📘](https://github.com/nodef/extra-array/wiki/CompareFunction)
 * @param a a value
 * @param b another value
 * @returns a<b: -ve, a=b: 0, a>b: +ve
 */
type CompareFunction<T> = (a: T, b: T) => number;
/**
 * Handle processing of values in an array.
 * [📘](https://github.com/nodef/extra-array/wiki/ProcessFunction)
 * @param v value in array
 * @param i index of value in array
 * @param x array containing the value
 */
type ProcessFunction<T> = (v: T, i: number, x: T[]) => void;
/**
 * Handle selection of values in an array.
 * [📘](https://github.com/nodef/extra-array/wiki/TestFunction)
 * @param v value in array
 * @param i index of value in array
 * @param x array containing the value
 * @returns selected?
 */
type TestFunction<T> = (v: T, i: number, x: T[]) => boolean;
/**
 * Handle transformation of a value to another.
 * [📘](https://github.com/nodef/extra-array/wiki/MapFunction)
 * @param v value in array
 * @param i index of value in array
 * @param x array containing the value
 * @returns transformed value
 */
type MapFunction<T, U> = (v: T, i: number, x: T[]) => U;
/**
 * Handle reduction of multiple values into a single value.
 * [📘](https://github.com/nodef/extra-array/wiki/ReduceFunction)
 * @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
 */
type ReduceFunction<T, U> = (acc: U, v: T, i: number, x: T[]) => U;
/**
 * Handle ending of a combined array.
 * [📘](https://github.com/nodef/extra-array/wiki/EndFunction)
 * @param dones iᵗʰ array done?
 * @returns combined array done?
 */
type EndFunction = (dones: boolean[]) => boolean;
/**
 * Handle swapping of two values in an array.
 * [📘](https://github.com/nodef/extra-array/wiki/SwapFunction)
 * @param x an array (updated!)
 * @param i an index
 * @param j another index
 * @returns x | x[i] ⇔ x[j]
 */
type SwapFunction<T> = (x: T[], i: number, j: number) => T[];
/**
 * Generate array from given number range.
 * [📘](https://github.com/nodef/extra-array/wiki/fromRange)
 * @param v start number
 * @param V end number, excluding
 * @param dv step size [1]
 * @returns [v, v+dv, v+2dv, ...]
 */
declare function fromRange(v: number, V: number, dv?: number): number[];
/**
 * Generate array from repeated function invocation.
 * [📘](https://github.com/nodef/extra-array/wiki/fromInvocation)
 * @param fn function
 * @param n number of values
 * @returns [fn(), fn(), ...]
 */
declare function fromInvocation<T>(fn: Function, n: number): T[];

/**
 * Generate array from repeated function application.
 * [📘](https://github.com/nodef/extra-array/wiki/fromApplication)
 * @param fm map function (v, i)
 * @param v start value
 * @param n number of values
 * @returns [v, fm(v), fm(fm(v)), ...]
 */
declare function fromApplication<T>(fm: MapFunction<T, T>, v: T, n: number): T[];

/**
 * Convert an iterable to array.
 * [📘](https://github.com/nodef/extra-array/wiki/fromIterable)
 * @param x an iterable
 * @returns x as array
 */
declare function fromIterable<T>(x: Iterable<T>): T[];

/**
 * Convert an iterable to array!
 * [📘](https://github.com/nodef/extra-array/wiki/fromIterable$)
 * @param x an iterable (updatable if array!)
 * @returns x as array
 */
declare function fromIterable$<T>(x: Iterable<T>): T[];

/**
 * Shallow clone an array.
 * [📘](https://github.com/nodef/extra-array/wiki/shallowClone)
 * @param x an array
 * @returns shallow clone of x
 */
declare function shallowClone<T>(x: T[]): T[];

/**
 * Deep clone an array.
 * [📘](https://github.com/nodef/extra-array/wiki/deepClone)
 * @param x an array
 * @returns deep clone of x
 */
declare function deepClone<T>(x: T[]): T[];
/**
 * Check if value is an array.
 * [📘](https://github.com/nodef/extra-array/wiki/is)
 * @param v a value
 * @returns v is an array?
 */
declare function is(v: any): v is any[];
/**
 * Obtain all indices.
 * [📘](https://github.com/nodef/extra-array/wiki/keys)
 * @param x an array
 * @returns [0, 1, ..., |x|-1]
 */
declare function keys<T>(x: T[]): number[];
/**
 * List all indices.
 * [📘](https://github.com/nodef/extra-array/wiki/ikeys)
 * @param x an array
 * @returns 0, 1, ..., |x|-1
 */
declare function ikeys<T>(x: T[]): IterableIterator<number>;
/**
 * Get all values.
 * [📘](https://github.com/nodef/extra-array/wiki/values)
 * @param x an array
 * @returns [v₀, v₁, ...] | vᵢ = x[i]
 */
declare function values<T>(x: T[]): T[];
/**
 * List all values.
 * [📘](https://github.com/nodef/extra-array/wiki/ivalues)
 * @param x an array
 * @returns v₀, v₁, ... | vᵢ = x[i]
 */
declare function ivalues<T>(x: T[]): IterableIterator<T>;
/**
 * Obtain all index-value pairs.
 * [📘](https://github.com/nodef/extra-array/wiki/entries)
 * @param x an array
 * @returns [[0, v₀], [1, v₁], ...] | vᵢ = x[i]
 */
declare function entries<T>(x: T[]): Entries<T>;
/**
 * List all index-value pairs.
 * [📘](https://github.com/nodef/extra-array/wiki/ientries)
 * @param x an array
 * @returns [0, v₀], [1, v₁], ... | vᵢ = x[i]
 */
declare function ientries<T>(x: T[]): IEntries<T>;
/**
 * Get zero-based index for an element in array.
 * [📘](https://github.com/nodef/extra-array/wiki/index)
 * @param x an array
 * @param i ±index
 * @returns i' | x[i'] = x[i]; i' ∈ [0, |x|]
 */
declare function index<T>(x: T[], i: number): number;
/**
 * Get zero-based index range for part of array.
 * [📘](https://github.com/nodef/extra-array/wiki/indexRange)
 * @param x an array
 * @param i begin ±index [0]
 * @param I end ±index (exclusive) [|x|]
 * @returns [i', I'] | i' ≤ I'; i', I' ∈ [0, |x|]
 */
declare function indexRange<T>(x: T[], i?: number, I?: number): [number, number];
/**
 * Check if an array is empty.
 * [📘](https://github.com/nodef/extra-array/wiki/isEmpty)
 * @param x an array
 * @returns |x| = 0?
 */
declare function isEmpty<T>(x: T[]): boolean;
/**
 * Find the length of an array.
 * [📘](https://github.com/nodef/extra-array/wiki/length)
 * @param x an array
 * @param i begin ±index [0]
 * @param I end ±index (exclusive) [X]
 * @returns |x[i..I]|
 */
declare function length<T>(x: T[], i?: number, I?: number): number;

/**
 * Resize an array to given length!
 * [📘](https://github.com/nodef/extra-array/wiki/resize$)
 * @param x an array
 * @param n new length
 * @param vd default value
 * @returns resized x
 */
declare function resize$<T>(x: T[], n: number, vd: T): T[];
/**
 * Remove all elements from an array!
 * [📘](https://github.com/nodef/extra-array/wiki/clear$)
 * @param x an array (updated!)
 * @returns cleared x
 */
declare function clear$<T>(x: T[]): T[];
/**
 * Get value at index.
 * [📘](https://github.com/nodef/extra-array/wiki/get)
 * @param x an array
 * @param i index
 * @returns x[i]
 */
declare function get<T>(x: T[], i: number): T;

/**
 * Get values at indices.
 * [📘](https://github.com/nodef/extra-array/wiki/getAll)
 * @param x an array
 * @param is indices
 * @returns [x[i₀], x[i₁], ...] | [i₀, i₁, ...] = is
 */
declare function getAll<T>(x: T[], is: number[]): T[];
/**
 * Get value at path in a nested array.
 * [📘](https://github.com/nodef/extra-array/wiki/getPath)
 * @param x a nested array
 * @param p path
 * @returns x[i₀][i₁][...] | [i₀, i₁, ...] = p
 */
declare function getPath(x: any[], p: number[]): any;
/**
 * Check if nested array has a path.
 * [📘](https://github.com/nodef/extra-array/wiki/hasPath)
 * @param x a nested array
 * @param p path
 * @returns x[i₀][i₁][...] exists? | [i₀, i₁, ...] = p
 */
declare function hasPath(x: any[], p: number[]): boolean;
/**
 * Set value at index.
 * [📘](https://github.com/nodef/extra-array/wiki/set)
 * @param x an array
 * @param i index
 * @param v value
 * @returns x' | x' = x; x'[i] = v
 */
declare function set<T>(x: T[], i: number, v: T): T[];

/**
 * Set value at index!
 * [📘](https://github.com/nodef/extra-array/wiki/set$)
 * @param x an array (updated!)
 * @param i index
 * @param v value
 * @returns x | x[i] = v
 */
declare function set$<T>(x: T[], i: number, v: T): T[];
/**
 * Set value at path in a nested array!
 * [📘](https://github.com/nodef/extra-array/wiki/setPath$)
 * @param x a nested array (updated!)
 * @param p path
 * @param v value
 * @returns x | x[i₀][i₁][...] = v; [i₀, i₁, ...] = p
 */
declare function setPath$(x: any[], p: number[], v: any): any[];
/**
 * Exchange two values.
 * [📘](https://github.com/nodef/extra-array/wiki/swap)
 * @param x an array
 * @param i an index
 * @param j another index
 * @returns x' | x' = x; x'[i] = x[j]; x'[j] = x[i]
 */
declare function swap<T>(x: T[], i: number, j: number): T[];
/**
 * Exchange two values!
 * [📘](https://github.com/nodef/extra-array/wiki/swap$)
 * @param x an array (updated!)
 * @param i an index
 * @param j another index
 * @returns x | x[i] ⇔ x[j]
 */
declare function swap$<T>(x: T[], i: number, j: number): T[];
/**
 * Exchange two ranges of values.
 * [📘](https://github.com/nodef/extra-array/wiki/swapRanges)
 * @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]
 */
declare function swapRanges<T>(x: T[], i: number, I: number, j: number, J: number): T[];
/**
 * Exchange two ranges of values!
 * [📘](https://github.com/nodef/extra-array/wiki/swapRanges$)
 * @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]
 */
declare function swapRanges$<T>(x: T[], i: number, I: number, j: number, J: number): T[];
/**
 * Remove value at index.
 * [📘](https://github.com/nodef/extra-array/wiki/remove)
 * @param x an array
 * @param i index
 * @returns x[0..i] ⧺ x[i+1..]
 */
declare function remove<T>(x: T[], i: number): T[];
/**
 * Remove value at index!
 * [📘](https://github.com/nodef/extra-array/wiki/remove$)
 * @param x an array (updated!)
 * @param i index
 * @returns x \\: [i]
 */
declare function remove$<T>(x: T[], i: number): T[];
/**
 * Remove value at path in a nested array!
 * [📘](https://github.com/nodef/extra-array/wiki/removePath$)
 * @param x a nested array (updated!)
 * @param p path
 * @returns x \\: [i₀][i₁][...] | [i₀, i₁, ...] = p
 */
declare function removePath$(x: any[], p: number[]): any[];
/**
 * Examine if array is sorted.
 * [📘](https://github.com/nodef/extra-array/wiki/isSorted)
 * @param x an array
 * @param fc compare function (a, b)
 * @param fm map function (v, i, x)
 * @returns x is sorted?
 */
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.
 * [📘](https://github.com/nodef/extra-array/wiki/hasUnsortedValue)
 * @param x an array
 * @param fc compare function (a, b)
 * @param fm map function (v, i, x)
 * @returns x is not sorted?
 */
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.
 * [📘](https://github.com/nodef/extra-array/wiki/searchUnsortedValue)
 * @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
 */
declare function searchUnsortedValue<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): number;
/**
 * Arrange values in order.
 * [📘](https://github.com/nodef/extra-array/wiki/sort)
 * @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
 */
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 values in order!
 * [📘](https://github.com/nodef/extra-array/wiki/sort$)
 * @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
 */
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.
 * [📘](https://github.com/nodef/extra-array/wiki/rangedSort)
 * @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
 */
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!
 * [📘](https://github.com/nodef/extra-array/wiki/rangedSort$)
 * @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
 */
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.
 * [📘](https://github.com/nodef/extra-array/wiki/partialSort)
 * @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
 */
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!
 * [📘](https://github.com/nodef/extra-array/wiki/partialSort$)
 * @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
 */
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.
 * [📘](https://github.com/nodef/extra-array/wiki/rangedPartialSort)
 * @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
 */
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!
 * [📘](https://github.com/nodef/extra-array/wiki/rangedPartialSort$)
 * @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
 */
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.
 * [📘](https://github.com/nodef/extra-array/wiki/minimum)
 * @param x an array
 * @param fc compare function (a, b)
 * @param fm map function (v, i, x)
 * @returns v | v ≤ vᵢ; vᵢ ∈ x
 */
declare function minimum<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): T;

/**
 * Find first smallest entry.
 * [📘](https://github.com/nodef/extra-array/wiki/minimumEntry)
 * @param x an array
 * @param fc compare function (a, b)
 * @param fm map function (v, i, x)
 * @returns [min_index, min_value]
 */
declare function minimumEntry<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): [number, T];

/**
 * Find first largest value.
 * [📘](https://github.com/nodef/extra-array/wiki/maximum)
 * @param x an array
 * @param fc compare function (a, b)
 * @param fm map function (v, i, x)
 * @returns v | v ≥ vᵢ; vᵢ ∈ x
 */
declare function maximum<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): T;

/**
 * Find first largest entry.
 * [📘](https://github.com/nodef/extra-array/wiki/maximumEntry)
 * @param x an array
 * @param fc compare function (a, b)
 * @param fm map function (v, i, x)
 * @returns [max_index, max_value]
 */
declare function maximumEntry<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): [number, T];

/**
 * Find smallest and largest values.
 * [📘](https://github.com/nodef/extra-array/wiki/range)
 * @param x an array
 * @param fc compare function (a, b)
 * @param fm map function (v, i, x)
 * @returns [min_value, max_value]
 */
declare function range<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): [T, T];
/**
 * Find smallest and largest entries.
 * [📘](https://github.com/nodef/extra-array/wiki/rangeEntries)
 * @param x an array
 * @param fc compare function (a, b)
 * @param fm map function (v, i, x)
 * @returns [min_entry, max_entry]
 */
declare function rangeEntries<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): [[number, T], [number, T]];
/**
 * Find smallest values.
 * [📘](https://github.com/nodef/extra-array/wiki/minimums)
 * @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
 */
declare function minimums<T, U = T>(x: T[], n: number, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): T[];
/**
 * Find smallest entries.
 * [📘](https://github.com/nodef/extra-array/wiki/minimumEntries)
 * @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
 */
declare function minimumEntries<T, U = T>(x: T[], n: number, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): [number, T][];
/**
 * Find largest values.
 * [📘](https://github.com/nodef/extra-array/wiki/maximums)
 * @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
 */
declare function maximums<T, U = T>(x: T[], n: number, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): T[];
/**
 * Find largest entries.
 * [📘](https://github.com/nodef/extra-array/wiki/maximumEntries)
 * @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
 */
declare function maximumEntries<T, U = T>(x: T[], n: number, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): [number, T][];
/**
 * Find first index of minimum value.
 * [📘](https://github.com/nodef/extra-array/wiki/searchMinimumValue)
 * @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
 */
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.
 * [📘](https://github.com/nodef/extra-array/wiki/searchMaximumValue)
 * @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
 */
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.
 * [📘](https://github.com/nodef/extra-array/wiki/searchMinimumValues)
 * @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
 */
declare function searchMinimumValues<T, U = T>(x: T[], n: number, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): number[];
/**
 * Find indices of maximum values.
 * [📘](https://github.com/nodef/extra-array/wiki/searchMaximumValues)
 * @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
 */
declare function searchMaximumValues<T, U = T>(x: T[], n: number, fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): number[];
/**
 * Examine if two arrays are equal.
 * [📘](https://github.com/nodef/extra-array/wiki/isEqual)
 * @param x an array
 * @param y another array
 * @param fc compare function (a, b)
 * @param fm map function (v, i, x)
 * @returns x = y?
 */
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).
 * [📘](https://github.com/nodef/extra-array/wiki/compare)
 * @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
 */
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.
 * [📘](https://github.com/nodef/extra-array/wiki/head)
 * @param x an array
 * @param vd default value
 * @returns x[0] || vd
 */
declare function head<T>(x: T[], vd?: T): T;

/**
 * Get values except first.
 * [📘](https://github.com/nodef/extra-array/wiki/tail)
 * @param x an array
 * @returns x[1..|x|]
 */
declare function tail<T>(x: T[]): T[];
/**
 * Get values except last.
 * [📘](https://github.com/nodef/extra-array/wiki/init)
 * @param x an array
 * @returns x[0..|x|-1]
 */
declare function init<T>(x: T[]): T[];
/**
 * Get last value.
 * [📘](https://github.com/nodef/extra-array/wiki/last)
 * @param x an array
 * @param vd default value
 * @returns x[|x|-1] || vd
 */
declare function last<T>(x: T[], vd?: T): T;

/**
 * Get values from middle.
 * [📘](https://github.com/nodef/extra-array/wiki/middle)
 * @param x an array
 * @param i begin index
 * @param n number of values [1]
 * @returns x[i..i+n]
 */
declare function middle<T>(x: T[], i: number, n?: number): T[];
/**
 * Get part of an array.
 * [📘](https://github.com/nodef/extra-array/wiki/slice)
 * @param x an array
 * @param i begin index [0]
 * @param I end index [|x|]
 * @returns x[i..I]
 */
declare function slice<T>(x: T[], i?: number, I?: number): T[];
/**
 * Get part of an array!
 * [📘](https://github.com/nodef/extra-array/wiki/slice$)
 * @param x an array (updated!)
 * @param i begin index [0]
 * @param I end index [|x|]
 * @returns x = x[i..I]
 */
declare function slice$<T>(x: T[], i?: number, I?: number): T[];
/**
 * Check if array has a value.
 * [📘](https://github.com/nodef/extra-array/wiki/includes)
 * @param x an array
 * @param v search value
 * @param i begin index [0]
 * @returns v ∈ x[i..]?
 */
declare function includes<T>(x: T[], v: T, i?: number): boolean;
/**
 * Examine if array has a value.
 * [📘](https://github.com/nodef/extra-array/wiki/hasValue)
 * @param x an array
 * @param v search value
 * @param fc compare function (a, b)
 * @param fm map function (v, i, x)
 * @returns v ∈ x?
 */
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.
 * [📘](https://github.com/nodef/extra-array/wiki/searchValue)
 * @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
 */
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.
 * [📘](https://github.com/nodef/extra-array/wiki/searchValueRight)
 * @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
 */
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.
 * [📘](https://github.com/nodef/extra-array/wiki/searchValueAll)
 * @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
 */
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.
 * [📘](https://github.com/nodef/extra-array/wiki/searchAdjacentDuplicateValue)
 * @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
 */
declare function searchAdjacentDuplicateValue<T, U = T>(x: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): number;

/**
 * Find first index where two arrays differ.
 * [📘](https://github.com/nodef/extra-array/wiki/searchMismatchedValue)
 * @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
 */
declare function searchMismatchedValue<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): number;

/**
 * Examine if array starts with a prefix.
 * [📘](https://github.com/nodef/extra-array/wiki/hasPrefix)
 * @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?
 */
declare function hasPrefix<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): boolean;

/**
 * Examine if array ends with a suffix.
 * [📘](https://github.com/nodef/extra-array/wiki/hasSuffix)
 * @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?
 */
declare function hasSuffix<T, U = T>(x: T[], y: T[], fc?: CompareFunction<T | U> | null, fm?: MapFunction<T, T | U> | null): boolean;

/**
 * Examine if array contains an infix.
 * [📘](https://github.com/nodef/extra-array/wiki/hasInfix)
 * @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?
 */
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.
 * [📘](https://github.com/nodef/extra-array/wiki/hasSubsequence)
 * @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₁ < ...
 */
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.
 * [📘](https://github.com/nodef/extra-array/wiki/hasPermutation)
 * @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?
 */
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.
 * [📘](https://github.com/nodef/extra-array/wiki/prefixes)
 * @param x an array
 * @param n number of values [-1 ⇒ any]
 * @returns [[], x[..1], x[..2], ...] if n<0; [x[..n]] otherwise
 */
declare function prefixes<T>(x: T[], n?: number): T[][];
/**
 * List all possible prefixes.
 * [📘](https://github.com/nodef/extra-array/wiki/iprefixes)
 * @param x an array
 * @param n number of values [-1 ⇒ any]
 * @returns [], x[..1], x[..2], ... if n<0; x[..n] otherwise
 */
declare function iprefixes<T>(x: T[], n?: number): IterableIterator<T[]>;
/**
 * Obtain all possible suffixes.
 * [📘](https://github.com/nodef/extra-array/wiki/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
 */
declare function suffixes<T>(x: T[], n?: number): T[][];
/**
 * List all possible suffixes.
 * [📘](https://github.com/nodef/extra-array/wiki/isuffixes)
 * @param x an array
 * @param n number of values [-1 ⇒ any]
 * @returns x[0..], x[1..], x[2..], ... if n<0; x[-n..] otherwise
 */
declare function isuffixes<T>(x: T[], n?: number): IterableIterator<T[]>;
/**
 * Obtain all possible infixes.
 * [📘](https://github.com/nodef/extra-array/wiki/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
 */
declare function infixes<T>(x: T[], n?: number): T[][];
/**
 * List all possible infixes.
 * [📘](https://github.com/nodef/extra-array/wiki/iinfixes)
 * @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
 */
declare function iinfixes<T>(x: T[], n?: number): IterableIterator<T[]>;
/**
 * Obtain all possible subsequences.
 * [📘](https://github.com/nodef/extra-array/wiki/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
 */
declare function subsequences<T>(x: T[], n?: number): T[][];
/**
 * List all possible subsequences.
 * [📘](https://github.com/nodef/extra-array/wiki/isubsequences)
 * @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
 */
declare function isubsequences<T>(x: T[], n?: number): IterableIterator<T[]>;
/**
 * Obtain all possible permutations.
 * [📘](https://github.com/nodef/extra-array/wiki/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
 */
declare function permutations<T>(x: T[], n?: number): T[][];
/**
 * List all possible permutations.
 * [📘](https://github.com/nodef/extra-array/wiki/ipermutations)
 * @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
 */
declare function ipermutations<T>(x: T[], n?: number): IterableIterator<T[]>;
/**
 * Find first index of an infix.
 * [📘](https://github.com/nodef/extra-array/wiki/searchInfix)
 * @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
 */
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.
 * [📘](https://github.com/nodef/extra-array/wiki/searchInfixRight)
 * @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
 */
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.
 * [📘](https://github.com/nodef/extra-array/wiki/searchInfixAll)
 * @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₁, ...]
 */
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.
 * [📘](https://github.com/nodef/extra-array/wiki/searchSubsequence)
 * @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
 */
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.
 * [📘](https://github.com/nodef/extra-array/wiki/randomValue)
 * @param x an array
 * @param fr random number generator ([0, 1))
 * @returns x[i] | i ∈ 0..|x|
 */
declare function randomValue<T>(x: T[], fr?: ReadFunction<number> | null): T;

/**
 * Pick an arbitrary prefix.
 * [📘](https://github.com/nodef/extra-array/wiki/randomPrefix)
 * @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|
 */
declare function randomPrefix<T>(x: T[], n?: number, fr?: ReadFunction<number> | null): T[];

/**
 * Pick an arbitrary suffix.
 * [📘](https://github.com/nodef/extra-array/wiki/randomSuffix)
 * @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|
 */
declare function randomSuffix<T>(x: T[], n?: number, fr?: ReadFunction<number> | null): T[];

/**
 * Pick an arbitrary infix.
 * [📘](https://github.com/nodef/extra-array/wiki/randomInfix)
 * @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|
 */
declare function randomInfix<T>(x: T[], n?: number, fr?: ReadFunction<number> | null): T[];

/**
 * Pick an arbitrary subsequence.
 * [📘](https://github.com/nodef/extra-array/wiki/randomSubsequence)
 * @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
 */
declare function randomSubsequence<T>(x: T[], n?: number, fr?: ReadFunction<number> | null): T[];

/**
 * Pick an arbitrary permutation.
 * [📘](https://github.com/nodef/extra-array/wiki/randomPermutation)
 * @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
 */
declare function randomPermutation<T>(x: T[], n?: number, fr?: ReadFunction<number> | null): T[];

/**
 * Pick an arbitrary permutation!
 * [📘](https://github.com/nodef/extra-array/wiki/randomPermutation$)
 * @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
 */
declare function randomPermutation$<T>(x: T[], n?: number, fr?: ReadFunction<number> | null): T[];

/**
 * Find first value passing a test.
 * [📘](https://github.com/nodef/extra-array/wiki/find)
 * @param x an array
 * @param ft test function (v, i, x)
 * @returns first v | ft(v) = true; v ∈ x
 */
declare function find<T>(x: T[], ft: TestFunction<T>): T;
/**
 * Find last value passing a test.
 * [📘](https://github.com/nodef/extra-array/wiki/findRight)
 * @param x an array
 * @param ft test function (v, i, x)
 * @returns last v | ft(v) = true; v ∈ x
 */
declare function findRight<T>(x: T[], ft: TestFunction<T>): T;
/**
 * Keep first n values only.
 * [📘](https://github.com/nodef/extra-array/wiki/take)
 * @param x an array
 * @param n number of values [1]
 * @returns x[0..n]
 */
declare function take<T>(x: T[], n?: number): T[];

/**
 * Keep last n values only.
 * [📘](https://github.com/nodef/extra-array/wiki/takeRight)
 * @param x an array
 * @param n number of values [1]
 * @returns x[0..n]
 */
declare function takeRight<T>(x: T[], n?: number): T[];

/**
 * Keep values from left, while a test passes.
 * [📘](https://github.com/nodef/extra-array/wiki/takeWhile)
 * @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
 */
declare function takeWhile<T>(x: T[], ft: TestFunction<T>): T[];
/**
 * Keep values from right, while a test passes.
 * [📘](https://github.com/nodef/extra-array/wiki/takeWhileRight)
 * @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
 */
declare function takeWhileRight<T>(x: T[], ft: TestFunction<T>): T[];
/**
 * Discard first n values only.
 * [📘](https://github.com/nodef/extra-array/wiki/drop)
 * @param x an array
 * @param n number of values [1]
 * @returns x[n..]
 */
declare function drop<T>(x: T[], n?: number): T[];
/**
 * Discard last n values only.
 * [📘](https://github.com/nodef/extra-array/wiki/dropRight)
 * @param x an array
 * @param n number of values [1]
 * @returns x[0..-n]
 */
declare function dropRight<T>(x: T[], n?: number): T[];
/**
 * Discard values from left, while a test passes.
 * [📘](https://github.com/nodef/extra-array/wiki/dropWhile)
 * @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
 */
declare function dropWhile<T>(x: T[], ft: TestFunction<T>): T[];
/**
 * Discard values from right, while a test passes.
 * [📘](https://github.com/nodef/extra-array/wiki/dropWhileRight)
 * @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
 */
declare function dropWhileRight<T>(x: T[], ft: TestFunction<T>): T[];
/**
 * Scan from left, while a test passes.
 * [📘](https://github.com/nodef/extra-array/wiki/scanWhile)
 * @param x an array
 * @param ft test function (v, i, x)
 * @returns first index where test fails
 */
declare function scanWhile<T>(x: T[], ft: TestFunction<T>): number;
/**
 * Scan from right, while a test passes.
 * [📘](https://github.com/nodef/extra-array/wiki/scanWhileRight)
 * @param x an array
 * @param ft test function (v, i, x)
 * @returns first index where test passes till end
 */
declare function scanWhileRight<T>(x: T[], ft: TestFunction<T>): number;
/**
 * Scan from left, until a test passes.
 * [📘](https://github.com/nodef/extra-array/wiki/scanUntil)
 * @param x an array
 * @param ft test function (v, i, x)
 * @returns first index where test passes
 */
declare function scanUntil<T>(x: T[], ft: TestFunction<T>): number;
/**
 * Scan from right, until a test passes.
 * [📘](https://github.com/nodef/extra-array/wiki/scanUntilRight)
 * @param x an array
 * @param ft test function (v, i, x)
 * @returns first index where test fails till end
 */
declare function scanUntilRight<T>(x: T[], ft: TestFunction<T>): number;
/**
 * Find first index of a value.
 * [📘](https://github.com/nodef/extra-array/wiki/indexOf)
 * @param x an array
 * @param v search value
 * @param i begin index [0]
 * @returns index of v in x[i..] if found else -1
 */
declare function indexOf<T>(x: T[], v: T, i?: number): number;
/**
 * Find last index of a value.
 * [📘](https://github.com/nodef/extra-array/wiki/lastIndexOf)
 * @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
 */
declare function lastIndexOf<T>(x: T[], v: T, i?: number): number;
/**
 * Find index of first value passing a test.
 * [📘](https://github.com/nodef/extra-array/wiki/search)
 * @param x an array
 * @param ft test function (v, i, x)
 * @returns first index of value, -1 if not found
 */
declare function search<T>(x: T[], ft: TestFunction<T>): number;

/**
 * Find index of last value passing a test.
 * [📘](https://github.com/nodef/extra-array/wiki/searchRight)
 * @param x an array
 * @param ft test function (v, i, x)
 * @returns last index of value, -1 if not found
 */
declare function searchRight<T>(x: T[], ft: TestFunction<T>): number;

/**
 * Find indices of values passing a test.
 * [📘](https://github.com/nodef/extra-array/wiki/searchAll)
 * @param x an array
 * @param ft test function (v, i, x)
 * @returns indices of value
 */
declare function searchAll<T>(x: T[], ft: TestFunction<T>): number[];
/**
 * Call a function for each value.
 * [📘](https://github.com/nodef/extra-array/wiki/forEach)
 * @param x an array
 * @param fp process function (v, i, x)
 */
declare function forEach<T>(x: T[], fp: ProcessFunction<T>): void;
/**
 * Examine if any value satisfies a test.
 * [📘](https://github.com/nodef/extra-array/wiki/some)
 * @param x an array
 * @param ft test function (v, i, x)
 * @returns true if ft(vᵢ) = true for some vᵢ ∈ x
 */
declare function some<T>(x: T[], ft?: TestFunction<T> | null): boolean;

/**
 * Examine if all values satisfy a test.
 * [📘](https://github.com/nodef/extra-array/wiki/every)
 * @param x an array
 * @param ft test function (v, i, x)
 * @returns true if ft(vᵢ) = true for all vᵢ ∈ x
 */
declare function every<T>(x: T[], ft?: TestFunction<T> | null): boolean;

/**
 * Transform values of an array.
 * [📘](https://github.com/nodef/extra-array/wiki/map)
 * @param x an array
 * @param fm map function (v, i, x)
 * @returns [fm(v₀), fm(v₁), ...] | vᵢ ∈ x
 */
declare function map<T, U = T>(x: T[], fm: MapFunction<T, T | U>): (T | U)[];
/**
 * Transform values of an array!
 * [📘](https://github.com/nodef/extra-array/wiki/map$)
 * @param x an array (updated!)
 * @param fm map function (v, i, x)
 * @returns x = [fm(v₀), fm(v₁), ...]; vᵢ ∈ x
 */
declare function map$<T>(x: T[], fm: MapFunction<T, T>): T[];
/**
 * Reduce values of array to a single value.
 * [📘](https://github.com/nodef/extra-array/wiki/reduce)
 * @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
 */
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.
 * [📘](https://github.com/nodef/extra-array/wiki/reduceRight)
 * @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
 */
declare function reduceRight<T, U = T>(x: T[], fr: ReduceFunction<T, T | U>, acc?: T | U): T | U;
/**
 * Keep values which pass a test.
 * [📘](https://github.com/nodef/extra-array/wiki/filter)
 * @param x an array
 * @param ft test function (v, i, x)
 * @returns [v₀, v₁, ...] | ft(vᵢ) = true; vᵢ ∈ x
 */
declare function filter<T>(x: T[], ft: TestFunction<T>): T[];

/**
 * Keep values which pass a test!
 * [📘](https://github.com/nodef/extra-array/wiki/filter$)
 * @param x an array (updated!)
 * @param ft test function (v, i, x)
 * @returns x = [v₀, v₁, ...] | ft(vᵢ) = true; vᵢ ∈ x
 */
declare function filter$<T>(x: T[], ft: TestFunction<T>): T[];
/**
 * Keep values at given indices.
 * [📘](https://github.com/nodef/extra-array/wiki/filterAt)
 * @param x an array
 * @param is indices
 * @returns v₀, v₁, ... | vᵢ = x[i]; i ∈ is
 */
declare function filterAt<T>(x: T[], is: number[]): T[];
/**
 * Discard values which pass a test.
 * [📘](https://github.com/nodef/extra-array/wiki/reject)
 * @param x an array
 * @param ft test function (v, i, x)
 * @returns [v₀, v₁, ...] | ft(vᵢ) = false; vᵢ ∈ x
 */
declare function reject<T>(x: T[], ft: TestFunction<T>): T[];
/**
 * Discard values which pass a test!
 * [📘](https://github.com/nodef/extra-array/wiki/reject$)
 * @param x an array (updated!)
 * @param ft test function (v, i, x)
 * @returns x = [v₀, v₁, ...] | ft(vᵢ) = false; vᵢ ∈ x
 */
declare function reject$<T>(x: T[], ft: TestFunction<T>): T[];
/**
 * Discard values at given indices.
 * [📘](https://github.com/nodef/extra-array/wiki/rejectAt)
 * @param x an array
 * @param is indices
 * @returns [v₀, v₁, ...] | vᵢ = x[i]; i ∉ is
 */
declare function rejectAt<T>(x: T[], is: number[]): T[];
/**
 * Flatten nested array to given depth.
 * [📘](https://github.com/nodef/extra-array/wiki/flat)
 * @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
 */
declare function flat(x: any[], n?: number, fm?: MapFunction<any, any> | null, ft?: TestFunction<any> | null): any[];
/**
 * Flatten nested array, based on map function.
 * [📘](https://github.com/nodef/extra-array/wiki/flatMap)
 * @param x an array
 * @param fm map function (v, i, x)
 * @param ft flatten test function (v, i, x) [is]
 * @returns flat iterable
 */
declare function flatMap(x: any[], fm?: MapFunction<any, any> | null, ft?: TestFunction<any> | null): any[];
/**
 * Perform exclusive prefix scan from left to right.
 * [📘](https://github.com/nodef/extra-array/wiki/exclusiveScan)
 * @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₁)...]
 */
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!
 * [📘](https://github.com/nodef/extra-array/wiki/exclusiveScan$)
 * @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₁)...]
 */
declare function exclusiveScan$<T>(x: T[], fr: ReduceFunction<T, T>, acc: T): T[];
/**
 * Perform inclusive prefix scan from left to right.
 * [📘](https://github.com/nodef/extra-array/wiki/inclusiveScan)
 * @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₁)...]
 */
declare function inclusiveScan<T, U = T>(x: T[], fr: ReduceFunction<T, T | U>, acc?: T | U): (T | U)[];

/**
 * Perform inclusive prefix scan from left to right!
 * [📘](https://github.com/nodef/extra-array/wiki/inclusiveScan$)
 * @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₁)...]
 */
declare function inclusiveScan$<T>(x: T[], fr: ReduceFunction<T, T>, acc: T): T[];
/**
 * Combine adjacent values of an array.
 * [📘](https://github.com/nodef/extra-array/wiki/adjacentCombine)
 * @param x an array
 * @param fc combine function (u, v)
 * @param acc initial value
 * @returns [fc(acc, v₀), fc(v₀, v₁)...] | vᵢ ∈ x
 */
declare function adjacentCombine<T>(x: T[], fc: CombineFunction<T>, acc: T): T[];
/**
 * Combine adjacent values of an array!
 * [📘](https://github.com/nodef/extra-array/wiki/adjacentCombine$)
 * @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
 */
declare function adjacentCombine$<T>(x: T[], fc: CombineFunction<T>, acc: T): T[];
/**
 * Place a separator between every value.
 * [📘](https://github.com/nodef/extra-array/wiki/intersperse)
 * @param x an array
 * @param v separator
 * @returns [x[0], v, x[1], v, ..., x[|x|-1]]
 */
declare function intersperse<T>(x: T[], v: T): T[];
/**
 * Estimate new values between existing ones.
 * [📘](https://github.com/nodef/extra-array/wiki/interpolate)
 * @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]]
 */
declare function interpolate<T>(x: T[], fc: CombineFunction<T>): T[];
/**
 * Place values of an array between another.
 * [📘](https://github.com/nodef/extra-array/wiki/intermix)
 * @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
 */
declare function intermix<T>(x: T[], y: T[], m?: number, n?: number, s?: number, t?: number): T[];
/**
 * Place values from iterables alternately.
 * [📘](https://github.com/nodef/extra-array/wiki/interleave)
 * @param xs arrays
 * @returns [x₀[0], x₁[0], ..., x₀[1], x₁[0], ...] | [x₀, x₁, ...] = xs
 */
declare function interleave<T>(xs: T[][]): T[];
/**
 * Combine values from arrays.
 * [📘](https://github.com/nodef/extra-array/wiki/zip)
 * @para