/**
* adapted from https://github.com/gcanti/fp-ts
*/
import "../../../Operator/index.js";
import type { Predicate, Refinement } from "../../../Function/core.js";
import type { Option } from "../../../Option/index.js";
import type { MutableArray } from "../../../Support/Mutable/index.js";
import type { NonEmptyArray } from "../NonEmptyArray/index.js";
import * as Tp from "../Tuple/index.js";
export declare type Array = ReadonlyArray;
/**
* Composes computations in sequence, using the return value of one computation to determine the next computation.
*
* @ets_data_first chain_
*/
export declare function chain(f: (a: A) => Array): (ma: Array) => Array;
/**
* Composes computations in sequence, using the return value of one computation to determine the next computation.
*/
export declare function chain_(fa: Array, f: (a: A) => Array): Array;
/**
* Splits an array into length-`n` pieces. The last piece will be shorter if `n` does not evenly divide the length of
* the array. Note that `split(n)([])` is `[]`, not `[[]]`. This is intentional, and is consistent with a recursive
* definition of `split`; it satisfies the property that
*
* ```ts
* split(n)(xs).concat(split(n)(ys)) == split(n)(xs.concat(ys)))
* ```
*
* whenever `n` evenly divides the length of `xs`.
*
* @ets_data_first split_
*/
export declare function split(n: number): (as: Array) => Array>;
/**
* Splits an array into length-`n` pieces. The last piece will be shorter if `n` does not evenly divide the length of
* the array. Note that `split(n)([])` is `[]`, not `[[]]`. This is intentional, and is consistent with a recursive
* definition of `split`; it satisfies the property that
*
* ```ts
* split(n)(xs).concat(split(n)(ys)) == split(n)(xs.concat(ys)))
* ```
*
* whenever `n` evenly divides the length of `xs`.
*/
export declare function split_(as: Array, n: number): Array>;
/**
* Filter out optional values
*/
export declare function compact(fa: Array>): Array;
/**
* Concatenate
*/
export declare function concat_(x: Array, y: Array): Array;
/**
* Concatenate
*
* @ets_data_first concat_
*/
export declare function concat(y: Array): (x: Array) => Array;
/**
* Attaches an element to the front of an array, creating a new non empty array
*
* ```ts
* assert.deepStrictEqual(prepend_(0, [1, 2, 3]), [0, 1, 2, 3])
* ```
*/
export declare function prepend_(tail: Array, head: A): Array;
/**
* Attaches an element to the front of an array, creating a new non empty array
*
* @ets_data_first prepend_
*/
export declare function prepend(head: A): (tail: Array) => Array;
/**
* Drop a number of elements from the start of an array, creating a new array
*
* ```ts
* assert.deepStrictEqual(drop(2)([1, 2, 3]), [3])
* ```
*
* @ets_data_first drop_
*/
export declare function drop(n: number): (as: Array) => Array;
/**
* Drop a number of elements from the start of an array, creating a new array
*/
export declare function drop_(as: Array, n: number): Array;
/**
* Remove the longest initial subarray for which all element satisfy the specified predicate, creating a new array
*
* ```ts
* assert.deepStrictEqual(dropWhile((n: number) => n % 2 === 1)([1, 3, 2, 4, 5]), [2, 4, 5])
* ```
*
* @ets_data_first dropWhile_
*/
export declare function dropWhile(predicate: Predicate): (as: Array) => Array;
/**
* Remove the longest initial subarray for which all element satisfy the specified predicate, creating a new array
*
* ```
* assert.deepStrictEqual(dropWhile((n: number) => n % 2 === 1)([1, 3, 2, 4, 5]), [2, 4, 5])
* ```
*/
export declare function dropWhile_(as: Array, predicate: Predicate): Array;
/**
* Drop a number of elements from the end of an array, creating a new array
*
* ```
* assert.deepStrictEqual(dropRight(2)([1, 2, 3, 4, 5]), [1, 2, 3])
* ```
*
* @ets_data_first dropRight_
*/
export declare function dropRight(n: number): (as: Array) => Array;
/**
* Drop a number of elements from the end of an array, creating a new array
*
* ```
* assert.deepStrictEqual(dropRight(2)([1, 2, 3, 4, 5]), [1, 2, 3])
* ```
*/
export declare function dropRight_(as: Array, n: number): Array;
/**
* An empty array
*/
export declare function empty(): Array;
/**
* Filters the array
*
* @ets_data_first filter_
*/
export declare function filter(refinement: Refinement): (fa: Array) => Array;
export declare function filter(predicate: Predicate): (fa: Array) => Array;
/**
* Filters the array
*/
export declare function filter_(fa: Array, refinement: Refinement): Array;
export declare function filter_(fa: Array, predicate: Predicate): Array;
/**
* Filters the array also passing element index
*
* @ets_data_first filterWithIndex_
*/
export declare function filterWithIndex(predicate: (i: number, a: A) => boolean): (nea: Array) => Array;
/**
* Filters the array also passing element index
*/
export declare function filterWithIndex_(nea: Array, predicate: (i: number, a: A) => boolean): Array;
/**
* Filters the array also mapping the output
*
* @ets_data_first collect_
*/
export declare const collect: (f: (a: A) => Option) => (fa: Array) => Array;
/**
* Filters the array also mapping the output
*/
export declare function collect_(fa: Array, f: (a: A) => Option): Array;
/**
* Filters the array also mapping the output
*
* @ets_data_first collectWithIndex_
*/
export declare function collectWithIndex(f: (i: number, a: A) => Option): (fa: Array) => Array;
/**
* Filters the array also mapping the output
*/
export declare function collectWithIndex_(fa: Array, f: (i: number, a: A) => Option): Array;
/**
* Maps an array until `none` is returned
*/
export declare function collectWhile_(arr: Array, f: (x: A) => Option): Array;
/**
* Maps an array until `none` is returned
*
* @ets_data_first collectWhile_
*/
export declare function collectWhile(f: (x: A) => Option): (arr: Array) => Array;
/**
* Find the first element which satisfies a predicate (or a refinement) function
*
* ```ts
* assert.deepStrictEqual(find((x: { a: number, b: number }) => x.a === 1)([{ a: 1, b: 1 }, { a: 1, b: 2 }]), some({ a: 1, b: 1 }))
* ```
*
* @ets_data_first find_
*/
export declare function find(refinement: Refinement): (as: Array) => Option;
export declare function find(predicate: Predicate): (as: Array) => Option;
/**
* Find the first element which satisfies a predicate (or a refinement) function
*/
export declare function find_(as: Array, refinement: Refinement): Option;
export declare function find_(as: Array, predicate: Predicate): Option;
/**
* Find the first element which satisfies a predicate (or a refinement) function
*/
export declare function findWithIndex_(as: Array, refinement: (i: number, a: A) => a is B): Option;
export declare function findWithIndex_(as: Array, predicate: (i: number, a: A) => boolean): Option;
/**
* Find the first element which satisfies a predicate (or a refinement) function
*
* @ets_data_first findWithIndex_
*/
export declare function findWithIndex(refinement: (i: number, a: A) => a is B): (as: Array) => Option;
export declare function findWithIndex(predicate: (i: number, a: A) => boolean): (as: Array) => Option;
/**
* Find the first index for which a predicate holds
*
* ```
* assert.deepStrictEqual(findIndex((n: number) => n === 2)([1, 2, 3]), some(1))
* assert.deepStrictEqual(findIndex((n: number) => n === 2)([]), none)
* ```
*
* @ets_data_first findIndex_
*/
export declare function findIndex(predicate: Predicate): (as: Array) => Option;
/**
* Find the first index for which a predicate holds
*/
export declare function findIndex_(as: Array, predicate: Predicate): Option;
/**
* Find the last element which satisfies a predicate function
*
* ```
* assert.deepStrictEqual(findLast((x: { a: number, b: number }) => x.a === 1)([{ a: 1, b: 1 }, { a: 1, b: 2 }]), some({ a: 1, b: 2 }))
* ```
*
* @ets_data_first findLast_
*/
export declare function findLast(refinement: Refinement): (as: Array) => Option;
export declare function findLast(predicate: Predicate): (as: Array) => Option;
/**
* Find the last element which satisfies a predicate function
*/
export declare function findLast_(as: Array, refinement: Refinement): Option;
export declare function findLast_(as: Array, predicate: Predicate): Option;
/**
* Returns the index of the last element of the list which matches the predicate
*
* ```ts
* interface X {
* a: number
* b: number
* }
* const xs: Array = [{ a: 1, b: 0 }, { a: 1, b: 1 }]
* assert.deepStrictEqual(findLastIndex((x: { a: number }) => x.a === 1)(xs), some(1))
* assert.deepStrictEqual(findLastIndex((x: { a: number }) => x.a === 4)(xs), none)
* ```
*
* @ets_data_first findLastIndex_
*/
export declare function findLastIndex(predicate: Predicate): (as: Array) => Option;
/**
* Returns the index of the last element of the list which matches the predicate
*/
export declare function findLastIndex_(as: Array, predicate: Predicate): Option;
/**
* Removes one level of nesting
*
* ```ts
* assert.deepStrictEqual(flatten([[1], [2], [3]]), [1, 2, 3])
* ```
*/
export declare function flatten(mma: Array>): Array;
/**
* Copies a mutable array into an immutable
*/
export declare function fromMutable(as: MutableArray): Array;
/**
* Get the first element in an array, or `None` if the array is empty
*
* ```ts
* assert.deepStrictEqual(head([1, 2, 3]), some(1))
* assert.deepStrictEqual(head([]), none)
* ```
*/
export declare function head(as: Array): Option;
/**
* Test whether an array is empty
*
* ```
* assert.strictEqual(isEmpty([]), true)
* ```
*/
export declare function isEmpty(as: Array): boolean;
/**
* Test whether an array is non empty narrowing down the type to `NonEmptyArray`
*/
export declare function isNonEmpty(as: Array): as is NonEmptyArray;
/**
* Get the last element in an array, or `None` if the array is empty
*
* ```ts
* assert.deepStrictEqual(last([1, 2, 3]), some(3))
* assert.deepStrictEqual(last([]), none)
* ```
*/
export declare function last(as: Array): Option;
/**
* This function provides a safe way to read a value at a particular index from an array
*
* ```ts
* assert.deepStrictEqual(get(1, [1, 2, 3]), some(2))
* assert.deepStrictEqual(get(3, [1, 2, 3]), none)
* ```
*/
export declare function get_(as: Array, i: number): Option;
/**
* This function provides a safe way to read a value at a particular index from an array
*
* @ets_data_first get_
*/
export declare function get(i: number): (as: Array) => Option;
/**
* Return a list of length `n` with element `i` initialized with `f(i)`
*
* ```ts
* const double = (n: number): number => n * 2
* assert.deepStrictEqual(makeBy_(5, double), [0, 2, 4, 6, 8])
* ```
*/
export declare function makeBy_(n: number, f: (i: number) => A): Array;
/**
* Return a list of length `n` with element `i` initialized with `f(i)`
*
* @ets_data_first makeBy_
*/
export declare function makeBy(f: (i: number) => A): (n: number) => Array;
/**
* Apply f to every element of Array returning Array
*
* @ets_data_first map_
*/
export declare function map(f: (a: A) => B): (fa: Array) => Array;
/**
* Apply f to every element of Array returning Array
*/
export declare function map_(fa: Array, f: (a: A) => B): Array;
/**
* Like map but also passes the index to f
*
* @ets_data_first mapWithIndex_
*/
export declare function mapWithIndex(f: (i: number, a: A) => B): (fa: Array) => Array;
/**
* Like map but also passes the index to f
*/
export declare function mapWithIndex_(fa: Array, f: (i: number, a: A) => B): Array;
/**
* Construct an array with a single element
*/
export declare function single(a: A): Array;
/**
* Create an array containing a range of integers, including both endpoints
*
* ```ts
* assert.deepStrictEqual(range(1, 5), [1, 2, 3, 4, 5])
* ```
*/
export declare function range(start: number, end: number): Array;
/**
* Construct B by compacting with f over the array from left to right
*
* @ets_data_first reduce_
*/
export declare function reduce(b: B, f: (b: B, a: A) => B): (fa: Array) => B;
/**
* Construct B by compacting with f over the array from left to right
*/
export declare function reduce_(fa: Array, b: B, f: (b: B, a: A) => B): B;
/**
* Construct B by compacting with f over the array from right to left
*
* @ets_data_first reduceRight_
*/
export declare function reduceRight(b: B, f: (a: A, b: B) => B): (fa: Array) => B;
/**
* Construct B by compacting with f over the array from right to left
*
*/
export declare function reduceRight_(fa: Array, b: B, f: (a: A, b: B) => B): B;
/**
* Construct B by compacting with f over the array from right to left
*
* @ets_data_first reduceRightWithIndex_
*/
export declare function reduceRightWithIndex(b: B, f: (i: number, a: A, b: B) => B): (fa: Array) => B;
/**
* Construct B by compacting with f over the array from right to left
*
*/
export declare function reduceRightWithIndex_(fa: Array, b: B, f: (i: number, a: A, b: B) => B): B;
/**
* Construct B by compacting with f over the array from left to right
*
* @ets_data_first reduceWithIndex_
*/
export declare function reduceWithIndex(b: B, f: (i: number, b: B, a: A) => B): (fa: Array) => B;
/**
* Construct B by compacting with f over the array from left to right
*/
export declare function reduceWithIndex_(fa: Array, b: B, f: (i: number, b: B, a: A) => B): B;
/**
* Create an array containing a value repeated the specified number of times
*
* ```ts
* assert.deepStrictEqual(replicate_(3, 'a'), ['a', 'a', 'a'])
* ```
*/
export declare function replicate_(n: number, a: A): Array;
/**
* Create an array containing a value repeated the specified number of times
*
* ```ts
* assert.deepStrictEqual(replicate_(3, 'a'), ['a', 'a', 'a'])
* ```
*
* @ets_data_first replicate_
*/
export declare function replicate(a: A): (n: number) => Array;
/**
* Reverse an array, creating a new array
*
* ```ts
* assert.deepStrictEqual(reverse([1, 2, 3]), [3, 2, 1])
* ```
*/
export declare function reverse(as: Array): Array;
/**
* Append an element to the end of an array, creating a new non empty array
*
* ```ts
* assert.deepStrictEqual(append_([1, 2, 3], 4), [1, 2, 3, 4])
* ```
*/
export declare function append_(init: Array, end: A): Array;
/**
* Append an element to the end of an array, creating a new non empty array
*
* @ets_data_first append_
*/
export declare function append(end: A): (init: Array) => Array;
/**
* Splits an array into two pieces, the first piece has `n` elements.
*
* ```ts
* assert.deepStrictEqual(splitAt(2)([1, 2, 3, 4, 5]), [[1, 2], [3, 4, 5]])
* ```
*
* @ets_data_first aplitAt_
*/
export declare function splitAt(n: number): (as: Array) => Tp.Tuple<[Array, Array]>;
/**
* Splits an array into two pieces, the first piece has `n` elements.
*/
export declare function splitAt_(as: Array, n: number): Tp.Tuple<[Array, Array]>;
/**
* Get all but the first element of an array, creating a new array, or `None` if the array is empty
*
* ```ts
* assert.deepStrictEqual(tail([1, 2, 3]), some([2, 3]))
* assert.deepStrictEqual(tail([]), none)
* ```
*/
export declare function tail(as: Array): Option>;
/**
* Keep only a number of elements from the start of an array, creating a new array.
* `n` must be a natural number
*
* ```ts
* assert.deepStrictEqual(take(2)([1, 2, 3]), [1, 2])
* ```
*
* @ets_data_first take_
*/
export declare function take(n: number): (as: Array) => Array;
/**
* Keep only a number of elements from the start of an array, creating a new array.
* `n` must be a natural number
*/
export declare function take_(as: Array, n: number): Array;
/**
* Calculate the longest initial subarray for which all element satisfy the specified predicate, creating a new array
*
* ```ts
* assert.deepStrictEqual(takeWhile((n: number) => n % 2 === 0)([2, 4, 3, 6]), [2, 4])
* ```
*
* @ets_data_first takeWhile_
*/
export declare function takeWhile(refinement: Refinement): (as: Array) => Array;
export declare function takeWhile(predicate: Predicate): (as: Array) => Array;
/**
* Calculate the longest initial subarray for which all element satisfy the specified predicate, creating a new array
*/
export declare function takeWhile_(as: Array, refinement: Refinement): Array;
export declare function takeWhile_(as: Array, predicate: Predicate): Array;
/**
* Keep only a number of elements from the end of an array, creating a new array.
* `n` must be a natural number
*
* ```ts
* assert.deepStrictEqual(takeRight(2)([1, 2, 3, 4, 5]), [4, 5])
* ```
*
* @ets_data_first takeRight_
*/
export declare function takeRight(n: number): (as: Array) => Array;
/**
* Keep only a number of elements from the end of an array, creating a new array.
* `n` must be a natural number
*/
export declare function takeRight_(as: Array, n: number): Array;
/**
* Copies this array into a mutable one
*/
export declare function toMutable(ras: Array): MutableArray;
/**
* Construct A by unfolding B signaling end with an option
*/
export declare function unfold_(b: B, f: (b: B) => Option>): Array;
/**
* Construct A by unfolding B signaling end with an option
*
* @ets_data_first unfold_
*/
export declare function unfold(f: (b: B) => Option>): (b: B) => Array;
/**
* The function is reverse of `zip`. Takes an array of pairs and return two corresponding arrays
*
* ```ts
* assert.deepStrictEqual(unzip([[1, 'a'], [2, 'b'], [3, 'c']]), [[1, 2, 3], ['a', 'b', 'c']])
* ```
*/
export declare function unzip(as: Array>): Tp.Tuple<[Array, Array]>;
/**
* Takes two arrays and returns an array of corresponding pairs. If one input array is short, excess elements of the
* longer array are discarded
*
* ```ts
* assert.deepStrictEqual(zip([1, 2, 3], ['a', 'b', 'c', 'd']), [[1, 'a'], [2, 'b'], [3, 'c']])
* ```
* @ets_data_first zip_
*/
export declare function zip(fb: Array): (fa: Array) => Array>;
/**
* Takes two arrays and returns an array of corresponding pairs. If one input array is short, excess elements of the
* longer array are discarded
*/
export declare function zip_(fa: Array, fb: Array): Array>;
/**
* Apply a function to pairs of elements at the same index in two arrays, collecting the results in a new array. If one
* input array is short, excess elements of the longer array are discarded.
*
* ```ts
* assert.deepStrictEqual(zipWith([1, 2, 3], ['a', 'b', 'c', 'd'], (n, s) => s + n), ['a1', 'b2', 'c3'])
* ```
*/
export declare function zipWith_(fa: Array, fb: Array, f: (a: A, b: B) => C): Array;
/**
* Apply a function to pairs of elements at the same index in two arrays, collecting the results in a new array. If one
* input array is short, excess elements of the longer array are discarded.
*
* @ets_data_first zipWith_
*/
export declare function zipWith(fb: Array, f: (a: A, b: B) => C): (fa: Array) => Array;
/**
* Constructs a new readonly array from an interable.
*/
export declare function from(as: Iterable): Array;
/**
* Joins together string arrays
*/
export declare function join_(as: Array, s: string): string;
/**
* Joins together string arrays
*
* @ets_data_first join_
*/
export declare function join(s: string): (as: Array) => string;
/**
* A useful recursion pattern for processing an array to produce a new array, often used for "chopping" up the input
* array. Typically chop is called with some function that will consume an initial prefix of the array and produce a
* value and the rest of the array.
*
* @ets_data_first chop_
*/
export declare function chop(f: (as: NonEmptyArray) => Tp.Tuple<[B, Array]>): (as: Array) => Array;
/**
* A useful recursion pattern for processing an array to produce a new array, often used for "chopping" up the input
* array. Typically chop is called with some function that will consume an initial prefix of the array and produce a
* value and the rest of the array.
*/
export declare function chop_(as: Array, f: (as: NonEmptyArray) => Tp.Tuple<[B, Array]>): Array;
/**
* Test whether an array contains a particular index
*/
export declare function isOutOfBound(i: number, as: Array): boolean;
/**
* Finds the first index that doesn't satisfy predicate or the length of as
*/
export declare function spanIndex_(as: Array, predicate: Predicate): number;
/**
* Split an array into two parts:
* 1. the longest initial subarray for which all elements satisfy the specified predicate
* 2. the remaining elements
*
* ```ts
* assert.deepStrictEqual(spanLeft((n: number) => n % 2 === 1)([1, 3, 2, 4, 5]), { init: [1, 3], rest: [2, 4, 5] })
* ```
*
* @ets_data_first spanLeft_
*/
export declare function spanLeft(refinement: Refinement): (as: Array) => Spanned;
export declare function spanLeft(predicate: Predicate): (as: Array) => Spanned;
/**
* Split an array into two parts:
* 1. the longest initial subarray for which all elements satisfy the specified predicate
* 2. the remaining elements
*/
export declare function spanLeft_(as: Array, refinement: Refinement): Spanned;
export declare function spanLeft_(as: Array, predicate: Predicate): Spanned;
export interface Spanned {
readonly init: Array;
readonly rest: Array;
}
/**
* Returns the size of an array
*/
export declare function size(as: Array): number;
/**
* Returns true if all the elements of the array match a predicate
*/
export declare function forAll_(as: Array, pred: Predicate): boolean;
/**
* Returns true if all the elements of the array match a predicate
*
* @ets_data_first forAll_
*/
export declare function forAll(pred: Predicate): (as: Array) => boolean;
/**
* Returns true if any the elements of the array match a predicate
*/
export declare function forAny_(as: Array, pred: Predicate): boolean;
/**
* Returns true if any the elements of the array match a predicate
*
* @ets_data_first forAny_
*/
export declare function forAny(pred: Predicate): (as: Array) => boolean;
/**
* Returns true if the array contains the element
*/
export declare function includes_(as: Array, elem: A): boolean;
/**
* Returns true if the array contains the element
*
* @ets_data_first includes_
*/
export declare function includes(elem: A): (as: Array) => boolean;
/**
* Returns a copy of the array
*/
export declare function copy(as: Array): Array;
//# sourceMappingURL=core.d.ts.map