Added in v2.0.0
Identifies an associative operation on a type constructor. It is similar to Semigroup
, except that it applies to
types of kind * -> *
.
Signature
export declare const alt: <A>(that: Lazy<A[]>) => (fa: A[]) => A[]
Added in v2.0.0
Less strict version of alt
.
Signature
export declare const altW: <B>(that: Lazy<B[]>) => <A>(fa: A[]) => (B | A)[]
Added in v2.9.0
Signature
export declare const zero: <A>() => A[]
Added in v2.7.0
Wrap a value into the type constructor.
Signature
export declare const of: <A>(a: A) => A[]
Added in v2.0.0
Apply a function to an argument under a type constructor.
Signature
export declare const ap: <A>(fa: A[]) => <B>(fab: ((a: A) => B)[]) => B[]
Added in v2.0.0
Signature
export declare const compact: <A>(fa: Option<A>[]) => A[]
Added in v2.0.0
Signature
export declare const separate: <A, B>(fa: Either<A, B>[]) => Separated<A[], B[]>
Added in v2.0.0
Signature
export declare const extend: <A, B>(f: (fa: A[]) => B) => (wa: A[]) => B[]
Added in v2.0.0
Signature
export declare const filter: {
<A, B extends A>(refinement: Refinement<A, B>): (fa: A[]) => B[]
<A>(predicate: Predicate<A>): (fa: A[]) => A[]
}
Added in v2.0.0
Signature
export declare const filterMap: <A, B>(f: (a: A) => Option<B>) => (fa: A[]) => B[]
Added in v2.0.0
Signature
export declare const partition: {
<A, B extends A>(refinement: Refinement<A, B>): (fa: A[]) => Separated<A[], B[]>
<A>(predicate: Predicate<A>): (fa: A[]) => Separated<A[], A[]>
}
Added in v2.0.0
Signature
export declare const partitionMap: <A, B, C>(f: (a: A) => Either<B, C>) => (fa: A[]) => Separated<B[], C[]>
Added in v2.0.0
Signature
export declare const filterMapWithIndex: <A, B>(f: (i: number, a: A) => Option<B>) => (fa: A[]) => B[]
Added in v2.0.0
Signature
export declare const filterWithIndex: {
<A, B extends A>(refinementWithIndex: RefinementWithIndex<number, A, B>): (fa: A[]) => B[]
<A>(predicateWithIndex: PredicateWithIndex<number, A>): (fa: A[]) => A[]
}
Added in v2.0.0
Signature
export declare const partitionMapWithIndex: <A, B, C>(
f: (i: number, a: A) => Either<B, C>
) => (fa: A[]) => Separated<B[], C[]>
Added in v2.0.0
Signature
export declare const partitionWithIndex: {
<A, B extends A>(refinementWithIndex: RefinementWithIndex<number, A, B>): (fa: A[]) => Separated<A[], B[]>
<A>(predicateWithIndex: PredicateWithIndex<number, A>): (fa: A[]) => Separated<A[], A[]>
}
Added in v2.0.0
Signature
export declare const foldMap: <M>(M: Monoid<M>) => <A>(f: (a: A) => M) => (fa: A[]) => M
Added in v2.0.0
Signature
export declare const reduce: <A, B>(b: B, f: (b: B, a: A) => B) => (fa: A[]) => B
Added in v2.0.0
Signature
export declare const reduceRight: <A, B>(b: B, f: (a: A, b: B) => B) => (fa: A[]) => B
Added in v2.0.0
Signature
export declare const foldMapWithIndex: <M>(M: Monoid<M>) => <A>(f: (i: number, a: A) => M) => (fa: A[]) => M
Added in v2.0.0
Signature
export declare const reduceRightWithIndex: <A, B>(b: B, f: (i: number, a: A, b: B) => B) => (fa: A[]) => B
Added in v2.0.0
Signature
export declare const reduceWithIndex: <A, B>(b: B, f: (i: number, b: B, a: A) => B) => (fa: A[]) => B
Added in v2.0.0
map
can be used to turn functions (a: A) => B
into functions (fa: F<A>) => F<B>
whose argument and return types
use the type constructor F
to represent some computational context.
Signature
export declare const map: <A, B>(f: (a: A) => B) => (fa: A[]) => B[]
Added in v2.0.0
Signature
export declare const mapWithIndex: <A, B>(f: (i: number, a: A) => B) => (fa: A[]) => B[]
Added in v2.0.0
Composes computations in sequence, using the return value of one computation to determine the next computation.
Signature
export declare const chain: <A, B>(f: (a: A) => B[]) => (ma: A[]) => B[]
Added in v2.0.0
for optimized and stack safe version check the data types sequenceArray
function
Signature
export declare const sequence: Sequence1<'Array'>
Added in v2.6.3
for optimized and stack safe version check the data types traverseArray
function
Signature
export declare const traverse: PipeableTraverse1<'Array'>
Added in v2.6.3
for optimized and stack safe version check the data types traverseArrayWithIndex
function
Signature
export declare const traverseWithIndex: PipeableTraverseWithIndex1<'Array', number>
Added in v2.6.3
Signature
export declare const unfold: <A, B>(b: B, f: (b: B) => Option<[A, B]>) => A[]
Added in v2.6.6
Signature
export declare const wilt: PipeableWilt1<'Array'>
Added in v2.6.5
Signature
export declare const wither: PipeableWither1<'Array'>
Added in v2.6.5
Combine two effectful actions, keeping only the result of the first.
Derivable from Apply
.
Signature
export declare const apFirst: <B>(fb: B[]) => <A>(fa: A[]) => A[]
Added in v2.0.0
Combine two effectful actions, keeping only the result of the second.
Derivable from Apply
.
Signature
export declare const apSecond: <B>(fb: B[]) => <A>(fa: A[]) => B[]
Added in v2.0.0
Composes computations in sequence, using the return value of one computation to determine the next computation and keeping only the result of the first.
Derivable from Monad
.
Signature
export declare const chainFirst: <A, B>(f: (a: A) => B[]) => (ma: A[]) => A[]
Added in v2.0.0
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.
Signature
export declare const chop: <A, B>(f: (as: NonEmptyArray<A>) => [B, A[]]) => (as: A[]) => B[]
Example
import { Eq, eqNumber } from 'fp-ts/Eq'
import { chop, spanLeft } from 'fp-ts/Array'
const group = <A>(S: Eq<A>): ((as: Array<A>) => Array<Array<A>>) => {
return chop((as) => {
const { init, rest } = spanLeft((a: A) => S.equals(a, as[0]))(as)
return [init, rest]
})
}
assert.deepStrictEqual(group(eqNumber)([1, 1, 2, 3, 3, 4]), [[1, 1], [2], [3, 3], [4]])
Added in v2.0.0
Signature
export declare const copy: <A>(as: A[]) => A[]
Added in v2.0.0
Creates an array of array values not included in the other given array using a Eq
for equality
comparisons. The order and references of result values are determined by the first array.
Signature
export declare const difference: <A>(E: Eq<A>) => { (xs: A[]): (ys: A[]) => A[]; (xs: A[], ys: A[]): A[] }
Example
import { difference } from 'fp-ts/Array'
import { eqNumber } from 'fp-ts/Eq'
import { pipe } from 'fp-ts/function'
assert.deepStrictEqual(pipe([1, 2], difference(eqNumber)([2, 3])), [1])
Added in v2.0.0
Drop a number of elements from the start of an array, creating a new array
Signature
export declare const dropLeft: (n: number) => <A>(as: A[]) => A[]
Example
import { dropLeft } from 'fp-ts/Array'
assert.deepStrictEqual(dropLeft(2)([1, 2, 3]), [3])
Added in v2.0.0
Remove the longest initial subarray for which all element satisfy the specified predicate, creating a new array
Signature
export declare const dropLeftWhile: <A>(predicate: Predicate<A>) => (as: A[]) => A[]
Example
import { dropLeftWhile } from 'fp-ts/Array'
assert.deepStrictEqual(dropLeftWhile((n: number) => n % 2 === 1)([1, 3, 2, 4, 5]), [2, 4, 5])
Added in v2.0.0
Drop a number of elements from the end of an array, creating a new array
Signature
export declare const dropRight: (n: number) => <A>(as: A[]) => A[]
Example
import { dropRight } from 'fp-ts/Array'
assert.deepStrictEqual(dropRight(2)([1, 2, 3, 4, 5]), [1, 2, 3])
Added in v2.0.0
Derivable from Extend
.
Signature
export declare const duplicate: <A>(wa: A[]) => A[][]
Added in v2.0.0
Removes one level of nesting.
Derivable from Monad
.
Signature
export declare const flatten: <A>(mma: A[][]) => A[]
Example
import { flatten } from 'fp-ts/Array'
assert.deepStrictEqual(flatten([[1], [2], [3]]), [1, 2, 3])
Added in v2.0.0
Creates an array of unique values that are included in all given arrays using a Eq
for equality
comparisons. The order and references of result values are determined by the first array.
Signature
export declare const intersection: <A>(E: Eq<A>) => { (xs: A[]): (ys: A[]) => A[]; (xs: A[], ys: A[]): A[] }
Example
import { intersection } from 'fp-ts/Array'
import { eqNumber } from 'fp-ts/Eq'
import { pipe } from 'fp-ts/function'
assert.deepStrictEqual(pipe([1, 2], intersection(eqNumber)([2, 3])), [2])
Added in v2.0.0
Places an element in between members of an array
Signature
export declare const intersperse: <A>(e: A) => (as: A[]) => A[]
Example
import { intersperse } from 'fp-ts/Array'
assert.deepStrictEqual(intersperse(9)([1, 2, 3, 4]), [1, 9, 2, 9, 3, 9, 4])
Added in v2.9.0
Extracts from an array of Either
all the Left
elements. All the Left
elements are extracted in order
Signature
export declare const lefts: <E, A>(as: Either<E, A>[]) => E[]
Example
import { lefts } from 'fp-ts/Array'
import { left, right } from 'fp-ts/Either'
assert.deepStrictEqual(lefts([right(1), left('foo'), right(2)]), ['foo'])
Added in v2.0.0
Prepend an element to every member of an array
Signature
export declare const prependToAll: <A>(e: A) => (xs: A[]) => A[]
Example
import { prependToAll } from 'fp-ts/Array'
assert.deepStrictEqual(prependToAll(9)([1, 2, 3, 4]), [9, 1, 9, 2, 9, 3, 9, 4])
Added in v2.9.0
Reverse an array, creating a new array
Signature
export declare const reverse: <A>(as: A[]) => A[]
Example
import { reverse } from 'fp-ts/Array'
assert.deepStrictEqual(reverse([1, 2, 3]), [3, 2, 1])
Added in v2.0.0
Extracts from an array of Either
all the Right
elements. All the Right
elements are extracted in order
Signature
export declare const rights: <E, A>(as: Either<E, A>[]) => A[]
Example
import { rights } from 'fp-ts/Array'
import { right, left } from 'fp-ts/Either'
assert.deepStrictEqual(rights([right(1), left('foo'), right(2)]), [1, 2])
Added in v2.0.0
Rotate an array to the right by n
steps
Signature
export declare const rotate: (n: number) => <A>(as: A[]) => A[]
Example
import { rotate } from 'fp-ts/Array'
assert.deepStrictEqual(rotate(2)([1, 2, 3, 4, 5]), [4, 5, 1, 2, 3])
Added in v2.0.0
Same as reduce
but it carries over the intermediate steps
Signature
export declare const scanLeft: <A, B>(b: B, f: (b: B, a: A) => B) => (as: A[]) => NonEmptyArray<B>
Example
import { scanLeft } from 'fp-ts/Array'
assert.deepStrictEqual(scanLeft(10, (b, a: number) => b - a)([1, 2, 3]), [10, 9, 7, 4])
Added in v2.0.0
Fold an array from the right, keeping all intermediate results instead of only the final result
Signature
export declare const scanRight: <A, B>(b: B, f: (a: A, b: B) => B) => (as: A[]) => NonEmptyArray<B>
Example
import { scanRight } from 'fp-ts/Array'
assert.deepStrictEqual(scanRight(10, (a: number, b) => b - a)([1, 2, 3]), [4, 5, 7, 10])
Added in v2.0.0
Sort the elements of an array in increasing order, creating a new array
Signature
export declare const sort: <B>(O: Ord<B>) => <A extends B>(as: A[]) => A[]
Example
import { sort } from 'fp-ts/Array'
import { ordNumber } from 'fp-ts/Ord'
assert.deepStrictEqual(sort(ordNumber)([3, 2, 1]), [1, 2, 3])
Added in v2.0.0
Sort the elements of an array in increasing order, where elements are compared using first ords[0]
, then ords[1]
,
etc...
Signature
export declare const sortBy: <B>(ords: Ord<B>[]) => <A extends B>(as: A[]) => A[]
Example
import { sortBy } from 'fp-ts/Array'
import { ord, ordString, ordNumber } from 'fp-ts/Ord'
interface Person {
name: string
age: number
}
const byName = ord.contramap(ordString, (p: Person) => p.name)
const byAge = ord.contramap(ordNumber, (p: Person) => p.age)
const sortByNameByAge = sortBy([byName, byAge])
const persons = [
{ name: 'a', age: 1 },
{ name: 'b', age: 3 },
{ name: 'c', age: 2 },
{ name: 'b', age: 2 },
]
assert.deepStrictEqual(sortByNameByAge(persons), [
{ name: 'a', age: 1 },
{ name: 'b', age: 2 },
{ name: 'b', age: 3 },
{ name: 'c', age: 2 },
])
Added in v2.0.0
Keep only a number of elements from the start of an array, creating a new array.
n
must be a natural number
Signature
export declare const takeLeft: (n: number) => <A>(as: A[]) => A[]
Example
import { takeLeft } from 'fp-ts/Array'
assert.deepStrictEqual(takeLeft(2)([1, 2, 3]), [1, 2])
Added in v2.0.0
Calculate the longest initial subarray for which all element satisfy the specified predicate, creating a new array
Signature
export declare function takeLeftWhile<A, B extends A>(refinement: Refinement<A, B>): (as: Array<A>) => Array<B>
export declare function takeLeftWhile<A>(predicate: Predicate<A>): (as: Array<A>) => Array<A>
Example
import { takeLeftWhile } from 'fp-ts/Array'
assert.deepStrictEqual(takeLeftWhile((n: number) => n % 2 === 0)([2, 4, 3, 6]), [2, 4])
Added in v2.0.0
Keep only a number of elements from the end of an array, creating a new array.
n
must be a natural number
Signature
export declare const takeRight: (n: number) => <A>(as: A[]) => A[]
Example
import { takeRight } from 'fp-ts/Array'
assert.deepStrictEqual(takeRight(2)([1, 2, 3, 4, 5]), [4, 5])
Added in v2.0.0
Creates an array of unique values, in order, from all given arrays using a Eq
for equality comparisons
Signature
export declare const union: <A>(E: Eq<A>) => { (xs: A[]): (ys: A[]) => A[]; (xs: A[], ys: A[]): A[] }
Example
import { union } from 'fp-ts/Array'
import { eqNumber } from 'fp-ts/Eq'
import { pipe } from 'fp-ts/function'
assert.deepStrictEqual(pipe([1, 2], union(eqNumber)([2, 3])), [1, 2, 3])
Added in v2.0.0
Remove duplicates from an array, keeping the first occurrence of an element.
Signature
export declare const uniq: <A>(E: Eq<A>) => (as: A[]) => A[]
Example
import { uniq } from 'fp-ts/Array'
import { eqNumber } from 'fp-ts/Eq'
assert.deepStrictEqual(uniq(eqNumber)([1, 2, 1]), [1, 2])
Added in v2.0.0
Takes two arrays and returns an array of corresponding pairs. If one input array is short, excess elements of the longer array are discarded
Signature
export declare const zip: { <B>(bs: B[]): <A>(as: A[]) => [A, B][]; <A, B>(as: A[], bs: B[]): [A, B][] }
Example
import { zip } from 'fp-ts/Array'
import { pipe } from 'fp-ts/function'
assert.deepStrictEqual(pipe([1, 2, 3], zip(['a', 'b', 'c', 'd'])), [
[1, 'a'],
[2, 'b'],
[3, 'c'],
])
Added in v2.0.0
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.
Signature
export declare const zipWith: <A, B, C>(fa: A[], fb: B[], f: (a: A, b: B) => C) => C[]
Example
import { zipWith } from 'fp-ts/Array'
assert.deepStrictEqual(
zipWith([1, 2, 3], ['a', 'b', 'c', 'd'], (n, s) => s + n),
['a1', 'b2', 'c3']
)
Added in v2.0.0
Array comprehension
[ f(x, y, ...) | x ← xs, y ← ys, ..., g(x, y, ...) ]
Signature
export declare function comprehension<A, B, C, D, R>(
input: [Array<A>, Array<B>, Array<C>, Array<D>],
f: (a: A, b: B, c: C, d: D) => R,
g?: (a: A, b: B, c: C, d: D) => boolean
): Array<R>
export declare function comprehension<A, B, C, R>(
input: [Array<A>, Array<B>, Array<C>],
f: (a: A, b: B, c: C) => R,
g?: (a: A, b: B, c: C) => boolean
): Array<R>
export declare function comprehension<A, R>(input: [Array<A>], f: (a: A) => R, g?: (a: A) => boolean): Array<R>
export declare function comprehension<A, B, R>(
input: [Array<A>, Array<B>],
f: (a: A, b: B) => R,
g?: (a: A, b: B) => boolean
): Array<R>
export declare function comprehension<A, R>(input: [Array<A>], f: (a: A) => boolean, g?: (a: A) => R): Array<R>
Example
import { comprehension } from 'fp-ts/Array'
import { tuple } from 'fp-ts/function'
assert.deepStrictEqual(
comprehension(
[
[1, 2, 3],
['a', 'b'],
],
tuple,
(a, b) => (a + b.length) % 2 === 0
),
[
[1, 'a'],
[1, 'b'],
[3, 'a'],
[3, 'b'],
]
)
Added in v2.0.0
Attaches an element to the front of an array, creating a new non empty array
Signature
export declare const cons: { <A>(head: A): (tail: A[]) => NonEmptyArray<A>; <A>(head: A, tail: A[]): NonEmptyArray<A> }
Example
import { cons } from 'fp-ts/Array'
import { pipe } from 'fp-ts/function'
assert.deepStrictEqual(pipe([1, 2, 3], cons(0)), [0, 1, 2, 3])
Added in v2.0.0
Return a list of length n
with element i
initialized with f(i)
Signature
export declare const makeBy: <A>(n: number, f: (i: number) => A) => A[]
Example
import { makeBy } from 'fp-ts/Array'
const double = (n: number): number => n * 2
assert.deepStrictEqual(makeBy(5, double), [0, 2, 4, 6, 8])
Added in v2.0.0
Create an array containing a range of integers, including both endpoints
Signature
export declare const range: (start: number, end: number) => Array<number>
Example
import { range } from 'fp-ts/Array'
assert.deepStrictEqual(range(1, 5), [1, 2, 3, 4, 5])
Added in v2.0.0
Create an array containing a value repeated the specified number of times
Signature
export declare const replicate: <A>(n: number, a: A) => A[]
Example
import { replicate } from 'fp-ts/Array'
assert.deepStrictEqual(replicate(3, 'a'), ['a', 'a', 'a'])
Added in v2.0.0
Append an element to the end of an array, creating a new non empty array
Signature
export declare const snoc: <A>(init: A[], end: A) => NonEmptyArray<A>
Example
import { snoc } from 'fp-ts/Array'
assert.deepStrictEqual(snoc([1, 2, 3], 4), [1, 2, 3, 4])
Added in v2.0.0
Find the first element which satisfies a predicate (or a refinement) function
Signature
export declare function findFirst<A, B extends A>(refinement: Refinement<A, B>): (as: Array<A>) => Option<B>
export declare function findFirst<A>(predicate: Predicate<A>): (as: Array<A>) => Option<A>
Example
import { findFirst } from 'fp-ts/Array'
import { some } from 'fp-ts/Option'
assert.deepStrictEqual(
findFirst((x: { a: number; b: number }) => x.a === 1)([
{ a: 1, b: 1 },
{ a: 1, b: 2 },
]),
some({ a: 1, b: 1 })
)
Added in v2.0.0
Find the first element returned by an option based selector function
Signature
export declare const findFirstMap: <A, B>(f: (a: A) => Option<B>) => (as: A[]) => Option<B>
Example
import { findFirstMap } from 'fp-ts/Array'
import { some, none } from 'fp-ts/Option'
interface Person {
name: string
age?: number
}
const persons: Array<Person> = [{ name: 'John' }, { name: 'Mary', age: 45 }, { name: 'Joey', age: 28 }]
// returns the name of the first person that has an age
assert.deepStrictEqual(findFirstMap((p: Person) => (p.age === undefined ? none : some(p.name)))(persons), some('Mary'))
Added in v2.0.0
Find the last element which satisfies a predicate function
Signature
export declare function findLast<A, B extends A>(refinement: Refinement<A, B>): (as: Array<A>) => Option<B>
export declare function findLast<A>(predicate: Predicate<A>): (as: Array<A>) => Option<A>
Example
import { findLast } from 'fp-ts/Array'
import { some } from 'fp-ts/Option'
assert.deepStrictEqual(
findLast((x: { a: number; b: number }) => x.a === 1)([
{ a: 1, b: 1 },
{ a: 1, b: 2 },
]),
some({ a: 1, b: 2 })
)
Added in v2.0.0
Find the last element returned by an option based selector function
Signature
export declare const findLastMap: <A, B>(f: (a: A) => Option<B>) => (as: A[]) => Option<B>
Example
import { findLastMap } from 'fp-ts/Array'
import { some, none } from 'fp-ts/Option'
interface Person {
name: string
age?: number
}
const persons: Array<Person> = [{ name: 'John' }, { name: 'Mary', age: 45 }, { name: 'Joey', age: 28 }]
// returns the name of the last person that has an age
assert.deepStrictEqual(findLastMap((p: Person) => (p.age === undefined ? none : some(p.name)))(persons), some('Joey'))
Added in v2.0.0
Break an array into its first element and remaining elements
Signature
export declare const foldLeft: <A, B>(onEmpty: Lazy<B>, onCons: (head: A, tail: A[]) => B) => (as: A[]) => B
Example
import { foldLeft } from 'fp-ts/Array'
const len: <A>(as: Array<A>) => number = foldLeft(
() => 0,
(_, tail) => 1 + len(tail)
)
assert.strictEqual(len([1, 2, 3]), 3)
Added in v2.0.0
Break an array into its initial elements and the last element
Signature
export declare const foldRight: <A, B>(onEmpty: Lazy<B>, onCons: (init: A[], last: A) => B) => (as: A[]) => B
Added in v2.0.0
Get the first element in an array, or None
if the array is empty
Signature
export declare const head: <A>(as: A[]) => Option<A>
Example
import { head } from 'fp-ts/Array'
import { some, none } from 'fp-ts/Option'
assert.deepStrictEqual(head([1, 2, 3]), some(1))
assert.deepStrictEqual(head([]), none)
Added in v2.0.0
Get all but the last element of an array, creating a new array, or None
if the array is empty
Signature
export declare const init: <A>(as: A[]) => Option<A[]>
Example
import { init } from 'fp-ts/Array'
import { some, none } from 'fp-ts/Option'
assert.deepStrictEqual(init([1, 2, 3]), some([1, 2]))
assert.deepStrictEqual(init([]), none)
Added in v2.0.0
Get the last element in an array, or None
if the array is empty
Signature
export declare const last: <A>(as: A[]) => Option<A>
Example
import { last } from 'fp-ts/Array'
import { some, none } from 'fp-ts/Option'
assert.deepStrictEqual(last([1, 2, 3]), some(3))
assert.deepStrictEqual(last([]), none)
Added in v2.0.0
Split an array into two parts:
Signature
export declare function spanLeft<A, B extends A>(
refinement: Refinement<A, B>
): (as: Array<A>) => { init: Array<B>; rest: Array<A> }
export declare function spanLeft<A>(predicate: Predicate<A>): (as: Array<A>) => { init: Array<A>; rest: Array<A> }
Example
import { spanLeft } from 'fp-ts/Array'
assert.deepStrictEqual(spanLeft((n: number) => n % 2 === 1)([1, 3, 2, 4, 5]), { init: [1, 3], rest: [2, 4, 5] })
Added in v2.0.0
Get all but the first element of an array, creating a new array, or None
if the array is empty
Signature
export declare const tail: <A>(as: A[]) => Option<A[]>
Example
import { tail } from 'fp-ts/Array'
import { some, none } from 'fp-ts/Option'
assert.deepStrictEqual(tail([1, 2, 3]), some([2, 3]))
assert.deepStrictEqual(tail([]), none)
Added in v2.0.0
Test whether an array is non empty narrowing down the type to NonEmptyArray<A>
Signature
export declare const isNonEmpty: <A>(as: A[]) => as is NonEmptyArray<A>
Added in v2.0.0
Signature
export declare const Alt: Alt1<'Array'>
Added in v2.7.0
Signature
export declare const Alternative: Alternative1<'Array'>
Added in v2.7.0
Signature
export declare const Applicative: Applicative1<'Array'>
Added in v2.7.0
Signature
export declare const Compactable: Compactable1<'Array'>
Added in v2.7.0
Signature
export declare const Extend: Extend1<'Array'>
Added in v2.7.0
Signature
export declare const Filterable: Filterable1<'Array'>
Added in v2.7.0
Signature
export declare const FilterableWithIndex: FilterableWithIndex1<'Array', number>
Added in v2.7.0
Signature
export declare const Foldable: Foldable1<'Array'>
Added in v2.7.0
Signature
export declare const FoldableWithIndex: FoldableWithIndex1<'Array', number>
Added in v2.7.0
Signature
export declare const Functor: Functor1<'Array'>
Added in v2.7.0
Signature
export declare const FunctorWithIndex: FunctorWithIndex1<'Array', number>
Added in v2.7.0
Signature
export declare const Monad: Monad1<'Array'>
Added in v2.7.0
Signature
export declare const Traversable: Traversable1<'Array'>
Added in v2.7.0
Signature
export declare const TraversableWithIndex: TraversableWithIndex1<'Array', number>
Added in v2.7.0
Signature
export declare const URI: 'Array'
Added in v2.0.0
Signature
export type URI = typeof URI
Added in v2.0.0
Signature
export declare const Unfoldable: Unfoldable1<'Array'>
Added in v2.7.0
Signature
export declare const Witherable: Witherable1<'Array'>
Added in v2.7.0
Signature
export declare const array: FunctorWithIndex1<'Array', number> &
Monad1<'Array'> &
Unfoldable1<'Array'> &
Alternative1<'Array'> &
Extend1<'Array'> &
FilterableWithIndex1<'Array', number> &
FoldableWithIndex1<'Array', number> &
TraversableWithIndex1<'Array', number> &
Witherable1<'Array'>
Added in v2.0.0
Derives an Eq
over the Array
of a given element type from the Eq
of that type. The derived Eq
defines two
arrays as equal if all elements of both arrays are compared equal pairwise with the given E
. In case of arrays of
different lengths, the result is non equality.
Signature
export declare const getEq: <A>(E: Eq<A>) => Eq<A[]>
Example
import { eqString } from 'fp-ts/Eq'
import { getEq } from 'fp-ts/Array'
const E = getEq(eqString)
assert.strictEqual(E.equals(['a', 'b'], ['a', 'b']), true)
assert.strictEqual(E.equals(['a'], []), false)
Added in v2.0.0
Returns a Monoid
for Array<A>
Signature
export declare const getMonoid: <A = never>() => Monoid<A[]>
Example
import { getMonoid } from 'fp-ts/Array'
const M = getMonoid<number>()
assert.deepStrictEqual(M.concat([1, 2], [3, 4]), [1, 2, 3, 4])
Added in v2.0.0
Derives an Ord
over the Array
of a given element type from the Ord
of that type. The ordering between two such
arrays is equal to: the first non equal comparison of each arrays elements taken pairwise in increasing order, in
case of equality over all the pairwise elements; the longest array is considered the greatest, if both arrays have
the same length, the result is equality.
Signature
export declare const getOrd: <A>(O: Ord<A>) => Ord<A[]>
Example
import { getOrd } from 'fp-ts/Array'
import { ordString } from 'fp-ts/Ord'
const O = getOrd(ordString)
assert.strictEqual(O.compare(['b'], ['a']), 1)
assert.strictEqual(O.compare(['a'], ['a']), 0)
assert.strictEqual(O.compare(['a'], ['b']), -1)
Added in v2.0.0
Signature
export declare const getShow: <A>(S: Show<A>) => Show<A[]>
Added in v2.0.0
Signature
export declare const unsafeDeleteAt: <A>(i: number, as: A[]) => A[]
Added in v2.0.0
Signature
export declare const unsafeInsertAt: <A>(i: number, a: A, as: A[]) => A[]
Added in v2.0.0
Signature
export declare const unsafeUpdateAt: <A>(i: number, a: A, as: A[]) => A[]
Added in v2.0.0
Signature
export declare const Do: {}[]
Added in v2.9.0
Signature
export declare const apS: <A, N extends string, B>(
name: Exclude<N, keyof A>,
fb: B[]
) => (fa: A[]) => { [K in N | keyof A]: K extends keyof A ? A[K] : B }[]
Added in v2.8.0
Signature
export declare const bind: <N extends string, A, B>(
name: Exclude<N, keyof A>,
f: (a: A) => B[]
) => (fa: A[]) => { [K in N | keyof A]: K extends keyof A ? A[K] : B }[]
Added in v2.8.0
Signature
export declare const bindTo: <N extends string>(name: N) => <A>(fa: A[]) => { [K in N]: A }[]
Added in v2.8.0
Signature
export declare const chainWithIndex: <A, B>(f: (index: number, a: A) => B[]) => (ma: A[]) => B[]
Added in v2.7.0
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 chunksOf(n)([])
is []
, not [[]]
. This is intentional, and is consistent with a recursive
definition of chunksOf
; it satisfies the property that
chunksOf(n)(xs).concat(chunksOf(n)(ys)) == chunksOf(n)(xs.concat(ys)))
whenever n
evenly divides the length of xs
.
Signature
export declare const chunksOf: (n: number) => <A>(as: A[]) => A[][]
Example
import { chunksOf } from 'fp-ts/Array'
assert.deepStrictEqual(chunksOf(2)([1, 2, 3, 4, 5]), [[1, 2], [3, 4], [5]])
Added in v2.0.0
Delete the element at the specified index, creating a new array, or returning None
if the index is out of bounds
Signature
export declare const deleteAt: (i: number) => <A>(as: A[]) => Option<A[]>
Example
import { deleteAt } from 'fp-ts/Array'
import { some, none } from 'fp-ts/Option'
assert.deepStrictEqual(deleteAt(0)([1, 2, 3]), some([2, 3]))
assert.deepStrictEqual(deleteAt(1)([]), none)
Added in v2.0.0
Test if a value is a member of an array. Takes a Eq<A>
as a single
argument which returns the function to use to search for a value of type A
in
an array of type Array<A>
.
Signature
export declare const elem: <A>(E: Eq<A>) => { (a: A): (as: A[]) => boolean; (a: A, as: A[]): boolean }
Example
import { elem } from 'fp-ts/Array'
import { eqNumber } from 'fp-ts/Eq'
import { pipe } from 'fp-ts/function'
assert.strictEqual(pipe([1, 2, 3], elem(eqNumber)(2)), true)
assert.strictEqual(pipe([1, 2, 3], elem(eqNumber)(0)), false)
Added in v2.0.0
An empty array
Signature
export declare const empty: never[]
Added in v2.0.0
Signature
export declare const every: <A>(predicate: Predicate<A>) => (as: A[]) => boolean
Added in v2.9.0
Find the first index for which a predicate holds
Signature
export declare const findIndex: <A>(predicate: Predicate<A>) => (as: A[]) => Option<number>
Example
import { findIndex } from 'fp-ts/Array'
import { some, none } from 'fp-ts/Option'
assert.deepStrictEqual(findIndex((n: number) => n === 2)([1, 2, 3]), some(1))
assert.deepStrictEqual(findIndex((n: number) => n === 2)([]), none)
Added in v2.0.0
Returns the index of the last element of the list which matches the predicate
Signature
export declare const findLastIndex: <A>(predicate: Predicate<A>) => (as: A[]) => Option<number>
Example
import { findLastIndex } from 'fp-ts/Array'
import { some, none } from 'fp-ts/Option'
interface X {
a: number
b: number
}
const xs: Array<X> = [
{ 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)
Added in v2.0.0
Insert an element at the specified index, creating a new array, or returning None
if the index is out of bounds
Signature
export declare const insertAt: <A>(i: number, a: A) => (as: A[]) => Option<A[]>
Example
import { insertAt } from 'fp-ts/Array'
import { some } from 'fp-ts/Option'
assert.deepStrictEqual(insertAt(2, 5)([1, 2, 3, 4]), some([1, 2, 5, 3, 4]))
Added in v2.0.0
Test whether an array is empty
Signature
export declare const isEmpty: <A>(as: A[]) => boolean
Example
import { isEmpty } from 'fp-ts/Array'
assert.strictEqual(isEmpty([]), true)
Added in v2.0.0
Test whether an array contains a particular index
Signature
export declare const isOutOfBound: <A>(i: number, as: A[]) => boolean
Added in v2.0.0
This function provides a safe way to read a value at a particular index from an array
Signature
export declare const lookup: { (i: number): <A>(as: A[]) => Option<A>; <A>(i: number, as: A[]): Option<A> }
Example
import { lookup } from 'fp-ts/Array'
import { some, none } from 'fp-ts/Option'
import { pipe } from 'fp-ts/function'
assert.deepStrictEqual(pipe([1, 2, 3], lookup(1)), some(2))
assert.deepStrictEqual(pipe([1, 2, 3], lookup(3)), none)
Added in v2.0.0
Apply a function to the element at the specified index, creating a new array, or returning None
if the index is out
of bounds
Signature
export declare const modifyAt: <A>(i: number, f: (a: A) => A) => (as: A[]) => Option<A[]>
Example
import { modifyAt } from 'fp-ts/Array'
import { some, none } from 'fp-ts/Option'
const double = (x: number): number => x * 2
assert.deepStrictEqual(modifyAt(1, double)([1, 2, 3]), some([1, 4, 3]))
assert.deepStrictEqual(modifyAt(1, double)([]), none)
Added in v2.0.0
Signature
export declare const some: <A>(predicate: Predicate<A>) => (as: A[]) => boolean
Added in v2.9.0
Splits an array into two pieces, the first piece has n
elements.
Signature
export declare const splitAt: (n: number) => <A>(as: A[]) => [A[], A[]]
Example
import { splitAt } from 'fp-ts/Array'
assert.deepStrictEqual(splitAt(2)([1, 2, 3, 4, 5]), [
[1, 2],
[3, 4, 5],
])
Added in v2.0.0
The function is reverse of zip
. Takes an array of pairs and return two corresponding arrays
Signature
export declare const unzip: <A, B>(as: [A, B][]) => [A[], B[]]
Example
import { unzip } from 'fp-ts/Array'
assert.deepStrictEqual(
unzip([
[1, 'a'],
[2, 'b'],
[3, 'c'],
]),
[
[1, 2, 3],
['a', 'b', 'c'],
]
)
Added in v2.0.0
Change the element at the specified index, creating a new array, or returning None
if the index is out of bounds
Signature
export declare const updateAt: <A>(i: number, a: A) => (as: A[]) => Option<A[]>
Example
import { updateAt } from 'fp-ts/Array'
import { some, none } from 'fp-ts/Option'
assert.deepStrictEqual(updateAt(1, 1)([1, 2, 3]), some([1, 1, 3]))
assert.deepStrictEqual(updateAt(1, 1)([]), none)
Added in v2.0.0