title | nav_order | parent |
---|---|---|
ReadonlyArray.ts |
83 |
Modules |
Added in v2.5.0
- Alt
- Apply
- ChainRec
- Compactable
- Extend
- Filterable
- FilterableWithIndex
- Foldable
- FoldableWithIndex
- Functor
- FunctorWithIndex
- Monad
- Pointed
- Traversable
- TraversableWithIndex
- Unfoldable
- Witherable
- Zero
- combinators
- apFirst
- apSecond
- chainFirst
- chainWithIndex
- chop
- chunksOf
- comprehension
- concat
- concatW
- difference
- dropLeft
- dropLeftWhile
- dropRight
- duplicate
- flap
- flatten
- fromEitherK
- fromOptionK
- intersection
- intersperse
- lefts
- prependAll
- reverse
- rights
- rotate
- scanLeft
- scanRight
- sort
- sortBy
- splitAt
- takeLeft
- takeLeftWhile
- takeRight
- union
- uniq
- unzip
- zip
- zipWith
prependToAll
- constructors
- destructors
- instances
- Alt
- Alternative
- Applicative
- Apply
- Chain
- ChainRecBreadthFirst
- ChainRecDepthFirst
- Compactable
- Extend
- Filterable
- FilterableWithIndex
- Foldable
- FoldableWithIndex
- FromEither
- Functor
- FunctorWithIndex
- Monad
- Pointed
- Traversable
- TraversableWithIndex
- URI
- URI (type alias)
- Unfoldable
- Witherable
- Zero
- getDifferenceMagma
- getEq
- getIntersectionSemigroup
- getMonoid
- getOrd
- getSemigroup
- getShow
- getUnionMonoid
- getUnionSemigroup
readonlyArray
- interop
- natural transformations
- refinements
- unsafe
- utils
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<readonly A[]>) => (fa: readonly A[]) => readonly A[]
Added in v2.5.0
Less strict version of alt
.
Signature
export declare const altW: <B>(that: Lazy<readonly B[]>) => <A>(fa: readonly A[]) => readonly (B | A)[]
Added in v2.9.0
Apply a function to an argument under a type constructor.
Signature
export declare const ap: <A>(fa: readonly A[]) => <B>(fab: readonly ((a: A) => B)[]) => readonly B[]
Added in v2.5.0
Signature
export declare const chainRecBreadthFirst: <A, B>(f: (a: A) => readonly Either<A, B>[]) => (a: A) => readonly B[]
Added in v2.11.0
Signature
export declare const chainRecDepthFirst: <A, B>(f: (a: A) => readonly Either<A, B>[]) => (a: A) => readonly B[]
Added in v2.11.0
Signature
export declare const compact: <A>(fa: readonly Option<A>[]) => readonly A[]
Added in v2.5.0
Signature
export declare const separate: <A, B>(fa: readonly Either<A, B>[]) => Separated<readonly A[], readonly B[]>
Added in v2.5.0
Signature
export declare const extend: <A, B>(f: (fa: readonly A[]) => B) => (wa: readonly A[]) => readonly B[]
Added in v2.5.0
Signature
export declare const filter: {
<A, B extends A>(refinement: Refinement<A, B>): (as: readonly A[]) => readonly B[]
<A>(predicate: Predicate<A>): <B extends A>(bs: readonly B[]) => readonly B[]
<A>(predicate: Predicate<A>): (as: readonly A[]) => readonly A[]
}
Added in v2.5.0
Signature
export declare const filterMap: <A, B>(f: (a: A) => Option<B>) => (fa: readonly A[]) => readonly B[]
Added in v2.5.0
Signature
export declare const partition: {
<A, B extends A>(refinement: Refinement<A, B>): (as: readonly A[]) => Separated<readonly A[], readonly B[]>
<A>(predicate: Predicate<A>): <B extends A>(bs: readonly B[]) => Separated<readonly B[], readonly B[]>
<A>(predicate: Predicate<A>): (as: readonly A[]) => Separated<readonly A[], readonly A[]>
}
Added in v2.5.0
Signature
export declare const partitionMap: <A, B, C>(
f: (a: A) => Either<B, C>
) => (fa: readonly A[]) => Separated<readonly B[], readonly C[]>
Added in v2.5.0
Signature
export declare const filterMapWithIndex: <A, B>(f: (i: number, a: A) => Option<B>) => (fa: readonly A[]) => readonly B[]
Added in v2.5.0
Signature
export declare const filterWithIndex: {
<A, B extends A>(refinementWithIndex: RefinementWithIndex<number, A, B>): (as: readonly A[]) => readonly B[]
<A>(predicateWithIndex: PredicateWithIndex<number, A>): <B extends A>(bs: readonly B[]) => readonly B[]
<A>(predicateWithIndex: PredicateWithIndex<number, A>): (as: readonly A[]) => readonly A[]
}
Added in v2.5.0
Signature
export declare const partitionMapWithIndex: <A, B, C>(
f: (i: number, a: A) => Either<B, C>
) => (fa: readonly A[]) => Separated<readonly B[], readonly C[]>
Added in v2.5.0
Signature
export declare const partitionWithIndex: {
<A, B extends A>(refinementWithIndex: RefinementWithIndex<number, A, B>): (
as: readonly A[]
) => Separated<readonly A[], readonly B[]>
<A>(predicateWithIndex: PredicateWithIndex<number, A>): <B extends A>(
bs: readonly B[]
) => Separated<readonly B[], readonly B[]>
<A>(predicateWithIndex: PredicateWithIndex<number, A>): (as: readonly A[]) => Separated<readonly A[], readonly A[]>
}
Added in v2.5.0
Signature
export declare const foldMap: <M>(M: Monoid<M>) => <A>(f: (a: A) => M) => (fa: readonly A[]) => M
Added in v2.5.0
Signature
export declare const reduce: <A, B>(b: B, f: (b: B, a: A) => B) => (fa: readonly A[]) => B
Added in v2.5.0
Signature
export declare const reduceRight: <A, B>(b: B, f: (a: A, b: B) => B) => (fa: readonly A[]) => B
Added in v2.5.0
Signature
export declare const foldMapWithIndex: <M>(M: Monoid<M>) => <A>(f: (i: number, a: A) => M) => (fa: readonly A[]) => M
Added in v2.5.0
Signature
export declare const reduceRightWithIndex: <A, B>(b: B, f: (i: number, a: A, b: B) => B) => (fa: readonly A[]) => B
Added in v2.5.0
Signature
export declare const reduceWithIndex: <A, B>(b: B, f: (i: number, b: B, a: A) => B) => (fa: readonly A[]) => B
Added in v2.5.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: readonly A[]) => readonly B[]
Added in v2.5.0
Signature
export declare const mapWithIndex: <A, B>(f: (i: number, a: A) => B) => (fa: readonly A[]) => readonly B[]
Added in v2.5.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) => readonly B[]) => (ma: readonly A[]) => readonly B[]
Added in v2.5.0
Signature
export declare const of: <A>(a: A) => readonly A[]
Added in v2.5.0
Signature
export declare const sequence: Sequence1<'ReadonlyArray'>
Added in v2.6.3
Signature
export declare const traverse: PipeableTraverse1<'ReadonlyArray'>
Added in v2.6.3
Signature
export declare const traverseWithIndex: PipeableTraverseWithIndex1<'ReadonlyArray', number>
Added in v2.6.3
Signature
export declare const unfold: <A, B>(b: B, f: (b: B) => Option<readonly [A, B]>) => readonly A[]
Added in v2.6.6
Signature
export declare const wilt: PipeableWilt1<'ReadonlyArray'>
Added in v2.6.5
Signature
export declare const wither: PipeableWither1<'ReadonlyArray'>
Added in v2.6.5
Signature
export declare const zero: <A>() => readonly A[]
Added in v2.7.0
Combine two effectful actions, keeping only the result of the first.
Derivable from Apply
.
Signature
export declare const apFirst: <B>(second: readonly B[]) => <A>(first: readonly A[]) => readonly A[]
Added in v2.5.0
Combine two effectful actions, keeping only the result of the second.
Derivable from Apply
.
Signature
export declare const apSecond: <B>(second: readonly B[]) => <A>(first: readonly A[]) => readonly B[]
Added in v2.5.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 Chain
.
Signature
export declare const chainFirst: <A, B>(f: (a: A) => readonly B[]) => (first: readonly A[]) => readonly A[]
Added in v2.5.0
Signature
export declare const chainWithIndex: <A, B>(f: (i: number, a: A) => readonly B[]) => (as: readonly A[]) => readonly B[]
Added in v2.7.0
A useful recursion pattern for processing a ReadonlyArray
to produce a new ReadonlyArray
, often used for "chopping" up the input
ReadonlyArray
. Typically chop
is called with some function that will consume an initial prefix of the ReadonlyArray
and produce a
value and the tail of the ReadonlyArray
.
Signature
export declare const chop: <A, B>(
f: (as: RNEA.ReadonlyNonEmptyArray<A>) => readonly [B, readonly A[]]
) => (as: readonly A[]) => readonly B[]
Example
import { Eq } from 'fp-ts/Eq'
import * as RA from 'fp-ts/ReadonlyArray'
import * as N from 'fp-ts/number'
import { pipe } from 'fp-ts/function'
const group = <A>(S: Eq<A>): ((as: ReadonlyArray<A>) => ReadonlyArray<ReadonlyArray<A>>) => {
return RA.chop((as) => {
const { init, rest } = pipe(
as,
RA.spanLeft((a: A) => S.equals(a, as[0]))
)
return [init, rest]
})
}
assert.deepStrictEqual(group(N.Eq)([1, 1, 2, 3, 3, 4]), [[1, 1], [2], [3, 3], [4]])
Added in v2.5.0
Splits a ReadonlyArray
into length-n
pieces. The last piece will be shorter if n
does not evenly divide the length of
the ReadonlyArray
. 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 as
.
Signature
export declare const chunksOf: (n: number) => <A>(as: readonly A[]) => readonly RNEA.ReadonlyNonEmptyArray<A>[]
Example
import { chunksOf } from 'fp-ts/ReadonlyArray'
assert.deepStrictEqual(chunksOf(2)([1, 2, 3, 4, 5]), [[1, 2], [3, 4], [5]])
Added in v2.5.0
ReadonlyArray
comprehension.
[ f(x, y, ...) | x ← xs, y ← ys, ..., g(x, y, ...) ]
Signature
export declare function comprehension<A, B, C, D, R>(
input: readonly [ReadonlyArray<A>, ReadonlyArray<B>, ReadonlyArray<C>, ReadonlyArray<D>],
f: (a: A, b: B, c: C, d: D) => R,
g?: (a: A, b: B, c: C, d: D) => boolean
): ReadonlyArray<R>
export declare function comprehension<A, B, C, R>(
input: readonly [ReadonlyArray<A>, ReadonlyArray<B>, ReadonlyArray<C>],
f: (a: A, b: B, c: C) => R,
g?: (a: A, b: B, c: C) => boolean
): ReadonlyArray<R>
export declare function comprehension<A, B, R>(
input: readonly [ReadonlyArray<A>, ReadonlyArray<B>],
f: (a: A, b: B) => R,
g?: (a: A, b: B) => boolean
): ReadonlyArray<R>
export declare function comprehension<A, R>(
input: readonly [ReadonlyArray<A>],
f: (a: A) => R,
g?: (a: A) => boolean
): ReadonlyArray<R>
Example
import { comprehension } from 'fp-ts/ReadonlyArray'
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.5.0
Signature
export declare const concat: <A>(second: readonly A[]) => (first: readonly A[]) => readonly A[]
Added in v2.11.0
Signature
export declare const concatW: <B>(second: readonly B[]) => <A>(first: readonly A[]) => readonly (B | A)[]
Added in v2.11.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 function difference<A>(
E: Eq<A>
): {
(xs: ReadonlyArray<A>): (ys: ReadonlyArray<A>) => ReadonlyArray<A>
(xs: ReadonlyArray<A>, ys: ReadonlyArray<A>): ReadonlyArray<A>
}
Example
import { difference } from 'fp-ts/ReadonlyArray'
import * as N from 'fp-ts/number'
import { pipe } from 'fp-ts/function'
assert.deepStrictEqual(pipe([1, 2], difference(N.Eq)([2, 3])), [1])
Added in v2.5.0
Drop a max number of elements from the start of an ReadonlyArray
, creating a new ReadonlyArray
.
Note. n
is normalized to a non negative integer.
Signature
export declare const dropLeft: (n: number) => <A>(as: readonly A[]) => readonly A[]
Example
import * as RA from 'fp-ts/ReadonlyArray'
import { pipe } from 'fp-ts/function'
const input: ReadonlyArray<number> = [1, 2, 3]
assert.deepStrictEqual(pipe(input, RA.dropLeft(2)), [3])
assert.strictEqual(pipe(input, RA.dropLeft(0)), input)
assert.strictEqual(pipe(input, RA.dropLeft(-1)), input)
Added in v2.5.0
Remove the longest initial subarray for which all element satisfy the specified predicate, creating a new array
Signature
export declare function dropLeftWhile<A, B extends A>(
refinement: Refinement<A, B>
): (as: ReadonlyArray<A>) => ReadonlyArray<B>
export declare function dropLeftWhile<A>(
predicate: Predicate<A>
): <B extends A>(bs: ReadonlyArray<B>) => ReadonlyArray<B>
export declare function dropLeftWhile<A>(predicate: Predicate<A>): (as: ReadonlyArray<A>) => ReadonlyArray<A>
Example
import { dropLeftWhile } from 'fp-ts/ReadonlyArray'
assert.deepStrictEqual(dropLeftWhile((n: number) => n % 2 === 1)([1, 3, 2, 4, 5]), [2, 4, 5])
Added in v2.5.0
Drop a max number of elements from the end of an ReadonlyArray
, creating a new ReadonlyArray
.
Note. n
is normalized to a non negative integer.
Signature
export declare const dropRight: (n: number) => <A>(as: readonly A[]) => readonly A[]
Example
import * as RA from 'fp-ts/ReadonlyArray'
import { pipe } from 'fp-ts/function'
const input: ReadonlyArray<number> = [1, 2, 3]
assert.deepStrictEqual(pipe(input, RA.dropRight(2)), [1])
assert.strictEqual(pipe(input, RA.dropRight(0)), input)
assert.strictEqual(pipe(input, RA.dropRight(-1)), input)
Added in v2.5.0
Derivable from Extend
.
Signature
export declare const duplicate: <A>(wa: readonly A[]) => readonly (readonly A[])[]
Added in v2.5.0
Derivable from Functor
.
Signature
export declare const flap: <A>(a: A) => <B>(fab: readonly ((a: A) => B)[]) => readonly B[]
Added in v2.10.0
Derivable from Chain
.
Signature
export declare const flatten: <A>(mma: readonly (readonly A[])[]) => readonly A[]
Added in v2.5.0
Signature
export declare const fromEitherK: <E, A, B>(f: (...a: A) => Either<E, B>) => (...a: A) => readonly B[]
Added in v2.11.0
Signature
export declare const fromOptionK: <A extends readonly unknown[], B>(
f: (...a: A) => Option<B>
) => (...a: A) => readonly B[]
Added in v2.11.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 function intersection<A>(
E: Eq<A>
): {
(xs: ReadonlyArray<A>): (ys: ReadonlyArray<A>) => ReadonlyArray<A>
(xs: ReadonlyArray<A>, ys: ReadonlyArray<A>): ReadonlyArray<A>
}
Example
import { intersection } from 'fp-ts/ReadonlyArray'
import * as N from 'fp-ts/number'
import { pipe } from 'fp-ts/function'
assert.deepStrictEqual(pipe([1, 2], intersection(N.Eq)([2, 3])), [2])
Added in v2.5.0
Places an element in between members of an array
Signature
export declare const intersperse: <A>(middle: A) => (as: readonly A[]) => readonly A[]
Example
import { intersperse } from 'fp-ts/ReadonlyArray'
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: readonly Either<E, A>[]) => readonly E[]
Example
import { lefts } from 'fp-ts/ReadonlyArray'
import { left, right } from 'fp-ts/Either'
assert.deepStrictEqual(lefts([right(1), left('foo'), right(2)]), ['foo'])
Added in v2.5.0
Prepend an element to every member of an array
Signature
export declare const prependAll: <A>(middle: A) => (as: readonly A[]) => readonly A[]
Example
import { prependAll } from 'fp-ts/ReadonlyArray'
assert.deepStrictEqual(prependAll(9)([1, 2, 3, 4]), [9, 1, 9, 2, 9, 3, 9, 4])
Added in v2.10.0
Reverse an array, creating a new array
Signature
export declare const reverse: <A>(as: readonly A[]) => readonly A[]
Example
import { reverse } from 'fp-ts/ReadonlyArray'
assert.deepStrictEqual(reverse([1, 2, 3]), [3, 2, 1])
Added in v2.5.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: readonly Either<E, A>[]) => readonly A[]
Example
import { rights } from 'fp-ts/ReadonlyArray'
import { right, left } from 'fp-ts/Either'
assert.deepStrictEqual(rights([right(1), left('foo'), right(2)]), [1, 2])
Added in v2.5.0
Rotate a ReadonlyArray
by n
steps.
Signature
export declare const rotate: (n: number) => <A>(as: readonly A[]) => readonly A[]
Example
import { rotate } from 'fp-ts/ReadonlyArray'
assert.deepStrictEqual(rotate(2)([1, 2, 3, 4, 5]), [4, 5, 1, 2, 3])
Added in v2.5.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: readonly A[]) => RNEA.ReadonlyNonEmptyArray<B>
Example
import { scanLeft } from 'fp-ts/ReadonlyArray'
assert.deepStrictEqual(scanLeft(10, (b, a: number) => b - a)([1, 2, 3]), [10, 9, 7, 4])
Added in v2.5.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: readonly A[]) => RNEA.ReadonlyNonEmptyArray<B>
Example
import { scanRight } from 'fp-ts/ReadonlyArray'
assert.deepStrictEqual(scanRight(10, (a: number, b) => b - a)([1, 2, 3]), [4, 5, 7, 10])
Added in v2.5.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: readonly A[]) => readonly A[]
Example
import { sort } from 'fp-ts/ReadonlyArray'
import * as N from 'fp-ts/number'
assert.deepStrictEqual(sort(N.Ord)([3, 2, 1]), [1, 2, 3])
Added in v2.5.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: readonly Ord<B>[]) => <A extends B>(as: readonly A[]) => readonly A[]
Example
import { sortBy } from 'fp-ts/ReadonlyArray'
import { contramap } from 'fp-ts/Ord'
import * as S from 'fp-ts/string'
import * as N from 'fp-ts/number'
import { pipe } from 'fp-ts/function'
interface Person {
readonly name: string
readonly age: number
}
const byName = pipe(
S.Ord,
contramap((p: Person) => p.name)
)
const byAge = pipe(
N.Ord,
contramap((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.5.0
Splits a ReadonlyArray
into two pieces, the first piece has max n
elements.
Signature
export declare const splitAt: (n: number) => <A>(as: readonly A[]) => readonly [readonly A[], readonly A[]]
Example
import { splitAt } from 'fp-ts/ReadonlyArray'
assert.deepStrictEqual(splitAt(2)([1, 2, 3, 4, 5]), [
[1, 2],
[3, 4, 5],
])
Added in v2.5.0
Keep only a max number of elements from the start of an ReadonlyArray
, creating a new ReadonlyArray
.
Note. n
is normalized to a non negative integer.
Signature
export declare const takeLeft: (n: number) => <A>(as: readonly A[]) => readonly A[]
Example
import * as RA from 'fp-ts/ReadonlyArray'
import { pipe } from 'fp-ts/function'
const input: ReadonlyArray<number> = [1, 2, 3]
assert.deepStrictEqual(pipe(input, RA.takeLeft(2)), [1, 2])
// out of bounds
assert.strictEqual(pipe(input, RA.takeLeft(4)), input)
assert.strictEqual(pipe(input, RA.takeLeft(-1)), input)
Added in v2.5.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: ReadonlyArray<A>) => ReadonlyArray<B>
export declare function takeLeftWhile<A>(
predicate: Predicate<A>
): <B extends A>(bs: ReadonlyArray<B>) => ReadonlyArray<B>
export declare function takeLeftWhile<A>(predicate: Predicate<A>): (as: ReadonlyArray<A>) => ReadonlyArray<A>
Example
import { takeLeftWhile } from 'fp-ts/ReadonlyArray'
assert.deepStrictEqual(takeLeftWhile((n: number) => n % 2 === 0)([2, 4, 3, 6]), [2, 4])
Added in v2.5.0
Keep only a max number of elements from the end of an ReadonlyArray
, creating a new ReadonlyArray
.
Note. n
is normalized to a non negative integer.
Signature
export declare const takeRight: (n: number) => <A>(as: readonly A[]) => readonly A[]
Example
import * as RA from 'fp-ts/ReadonlyArray'
import { pipe } from 'fp-ts/function'
const input: ReadonlyArray<number> = [1, 2, 3]
assert.deepStrictEqual(pipe(input, RA.takeRight(2)), [2, 3])
// out of bounds
assert.strictEqual(pipe(input, RA.takeRight(4)), input)
assert.strictEqual(pipe(input, RA.takeRight(-1)), input)
Added in v2.5.0
Creates an array of unique values, in order, from all given arrays using a Eq
for equality comparisons
Signature
export declare function union<A>(
E: Eq<A>
): {
(xs: ReadonlyArray<A>): (ys: ReadonlyArray<A>) => ReadonlyArray<A>
(xs: ReadonlyArray<A>, ys: ReadonlyArray<A>): ReadonlyArray<A>
}
Example
import { union } from 'fp-ts/ReadonlyArray'
import * as N from 'fp-ts/number'
import { pipe } from 'fp-ts/function'
assert.deepStrictEqual(pipe([1, 2], union(N.Eq)([2, 3])), [1, 2, 3])
Added in v2.5.0
Remove duplicates from an array, keeping the first occurrence of an element.
Signature
export declare const uniq: <A>(E: Eq<A>) => (as: readonly A[]) => readonly A[]
Example
import { uniq } from 'fp-ts/ReadonlyArray'
import * as N from 'fp-ts/number'
assert.deepStrictEqual(uniq(N.Eq)([1, 2, 1]), [1, 2])
Added in v2.5.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: readonly (readonly [A, B])[]) => readonly [readonly A[], readonly B[]]
Example
import { unzip } from 'fp-ts/ReadonlyArray'
assert.deepStrictEqual(
unzip([
[1, 'a'],
[2, 'b'],
[3, 'c'],
]),
[
[1, 2, 3],
['a', 'b', 'c'],
]
)
Added in v2.5.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 function zip<B>(bs: ReadonlyArray<B>): <A>(as: ReadonlyArray<A>) => ReadonlyArray<readonly [A, B]>
export declare function zip<A, B>(as: ReadonlyArray<A>, bs: ReadonlyArray<B>): ReadonlyArray<readonly [A, B]>
Example
import { zip } from 'fp-ts/ReadonlyArray'
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.5.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: readonly A[], fb: readonly B[], f: (a: A, b: B) => C) => readonly C[]
Example
import { zipWith } from 'fp-ts/ReadonlyArray'
assert.deepStrictEqual(
zipWith([1, 2, 3], ['a', 'b', 'c', 'd'], (n, s) => s + n),
['a1', 'b2', 'c3']
)
Added in v2.5.0
Use prependAll
instead.
Signature
export declare const prependToAll: <A>(middle: A) => (as: readonly A[]) => readonly A[]
Added in v2.9.0
Append an element to the end of a ReadonlyArray
, creating a new ReadonlyNonEmptyArray
.
Signature
export declare const append: <A>(end: A) => (init: readonly A[]) => RNEA.ReadonlyNonEmptyArray<A>
Example
import { append } from 'fp-ts/ReadonlyArray'
import { pipe } from 'fp-ts/function'
assert.deepStrictEqual(pipe([1, 2, 3], append(4)), [1, 2, 3, 4])
Added in v2.10.0
Less strict version of append
.
Signature
export declare const appendW: <B>(end: B) => <A>(init: readonly A[]) => RNEA.ReadonlyNonEmptyArray<B | A>
Added in v2.11.0
Signature
export declare function fromPredicate<A, B extends A>(refinement: Refinement<A, B>): (a: A) => ReadonlyArray<B>
export declare function fromPredicate<A>(predicate: Predicate<A>): <B extends A>(b: B) => ReadonlyArray<B>
export declare function fromPredicate<A>(predicate: Predicate<A>): (a: A) => ReadonlyArray<A>
Added in v2.11.0
Signature
export declare const guard: (b: boolean) => readonly void[]
Added in v2.11.0
Return a ReadonlyArray
of length n
with element i
initialized with f(i)
.
Note. n
is normalized to a non negative integer.
Signature
export declare const makeBy: <A>(n: number, f: (i: number) => A) => readonly A[]
Example
import { makeBy } from 'fp-ts/ReadonlyArray'
const double = (n: number): number => n * 2
assert.deepStrictEqual(makeBy(5, double), [0, 2, 4, 6, 8])
Added in v2.5.0
Prepend an element to the front of a ReadonlyArray
, creating a new ReadonlyNonEmptyArray
.
Signature
export declare const prepend: <A>(head: A) => (tail: readonly A[]) => RNEA.ReadonlyNonEmptyArray<A>
Example
import { prepend } from 'fp-ts/ReadonlyArray'
import { pipe } from 'fp-ts/function'
assert.deepStrictEqual(pipe([2, 3, 4], prepend(1)), [1, 2, 3, 4])
Added in v2.10.0
Less strict version of prepend
.
Signature
export declare const prependW: <B>(head: B) => <A>(tail: readonly A[]) => RNEA.ReadonlyNonEmptyArray<B | A>
Added in v2.11.0
Create a ReadonlyArray
containing a value repeated the specified number of times.
Note. n
is normalized to a non negative integer.
Signature
export declare const replicate: <A>(n: number, a: A) => readonly A[]
Example
import { replicate } from 'fp-ts/ReadonlyArray'
assert.deepStrictEqual(replicate(3, 'a'), ['a', 'a', 'a'])
Added in v2.5.0
Use prepend
instead.
Signature
export declare const cons: typeof RNEA.cons
Added in v2.5.0
Use ReadonlyNonEmptyArray
module instead.
Signature
export declare const range: (start: number, end: number) => RNEA.ReadonlyNonEmptyArray<number>
Added in v2.5.0
Use append
instead.
Signature
export declare const snoc: <A>(init: readonly A[], end: A) => RNEA.ReadonlyNonEmptyArray<A>
Added in v2.5.0
Alias of matchLeft
.
Signature
export declare const foldLeft: <A, B>(
onEmpty: Lazy<B>,
onNonEmpty: (head: A, tail: readonly A[]) => B
) => (as: readonly A[]) => B
Added in v2.5.0
Alias of matchRight
.
Signature
export declare const foldRight: <A, B>(
onEmpty: Lazy<B>,
onNonEmpty: (init: readonly A[], last: A) => B
) => (as: readonly A[]) => B
Added in v2.5.0
Signature
export declare const match: <B, A>(
onEmpty: Lazy<B>,
onNonEmpty: (as: RNEA.ReadonlyNonEmptyArray<A>) => B
) => (as: readonly A[]) => B
Added in v2.11.0
Break a ReadonlyArray
into its first element and remaining elements.
Signature
export declare const matchLeft: <B, A>(
onEmpty: Lazy<B>,
onNonEmpty: (head: A, tail: readonly A[]) => B
) => (as: readonly A[]) => B
Example
import { matchLeft } from 'fp-ts/ReadonlyArray'
const len: <A>(as: ReadonlyArray<A>) => number = matchLeft(
() => 0,
(_, tail) => 1 + len(tail)
)
assert.strictEqual(len([1, 2, 3]), 3)
Added in v2.10.0
Less strict version of matchLeft
.
Signature
export declare const matchLeftW: <B, A, C>(
onEmpty: Lazy<B>,
onNonEmpty: (head: A, tail: readonly A[]) => C
) => (as: readonly A[]) => B | C
Added in v2.11.0
Break a ReadonlyArray
into its initial elements and the last element.
Signature
export declare const matchRight: <B, A>(
onEmpty: Lazy<B>,
onNonEmpty: (init: readonly A[], last: A) => B
) => (as: readonly A[]) => B
Added in v2.10.0
Less strict version of matchRight
.
Signature
export declare const matchRightW: <B, A, C>(
onEmpty: Lazy<B>,
onNonEmpty: (init: readonly A[], last: A) => C
) => (as: readonly A[]) => B | C
Added in v2.11.0
Less strict version of match
.
Signature
export declare const matchW: <B, A, C>(
onEmpty: Lazy<B>,
onNonEmpty: (as: RNEA.ReadonlyNonEmptyArray<A>) => C
) => (as: readonly A[]) => B | C
Added in v2.11.0
Signature
export declare const Alt: Alt1<'ReadonlyArray'>
Added in v2.7.0
Signature
export declare const Alternative: Alternative1<'ReadonlyArray'>
Added in v2.7.0
Signature
export declare const Applicative: Applicative1<'ReadonlyArray'>
Added in v2.7.0
Signature
export declare const Apply: Apply1<'ReadonlyArray'>
Added in v2.10.0
Signature
export declare const Chain: Chain1<'ReadonlyArray'>
Added in v2.10.0
Signature
export declare const ChainRecBreadthFirst: ChainRec1<'ReadonlyArray'>
Added in v2.11.0
Signature
export declare const ChainRecDepthFirst: ChainRec1<'ReadonlyArray'>
Added in v2.11.0
Signature
export declare const Compactable: Compactable1<'ReadonlyArray'>
Added in v2.7.0
Signature
export declare const Extend: Extend1<'ReadonlyArray'>
Added in v2.7.0
Signature
export declare const Filterable: Filterable1<'ReadonlyArray'>
Added in v2.7.0
Signature
export declare const FilterableWithIndex: FilterableWithIndex1<'ReadonlyArray', number>
Added in v2.7.0
Signature
export declare const Foldable: Foldable1<'ReadonlyArray'>
Added in v2.7.0
Signature
export declare const FoldableWithIndex: FoldableWithIndex1<'ReadonlyArray', number>
Added in v2.7.0
Signature
export declare const FromEither: FromEither1<'ReadonlyArray'>
Added in v2.11.0
Signature
export declare const Functor: Functor1<'ReadonlyArray'>
Added in v2.7.0
Signature
export declare const FunctorWithIndex: FunctorWithIndex1<'ReadonlyArray', number>
Added in v2.7.0
Signature
export declare const Monad: Monad1<'ReadonlyArray'>
Added in v2.7.0
Signature
export declare const Pointed: Pointed1<'ReadonlyArray'>
Added in v2.10.0
Signature
export declare const Traversable: Traversable1<'ReadonlyArray'>
Added in v2.7.0
Signature
export declare const TraversableWithIndex: TraversableWithIndex1<'ReadonlyArray', number>
Added in v2.7.0
Signature
export declare const URI: 'ReadonlyArray'
Added in v2.5.0
Signature
export type URI = typeof URI
Added in v2.5.0
Signature
export declare const Unfoldable: Unfoldable1<'ReadonlyArray'>
Added in v2.7.0
Signature
export declare const Witherable: Witherable1<'ReadonlyArray'>
Added in v2.7.0
Signature
export declare const Zero: Zero1<'ReadonlyArray'>
Added in v2.11.0
Signature
export declare const getDifferenceMagma: <A>(E: Eq<A>) => Magma<readonly A[]>
Added in v2.11.0
Derives an Eq
over the ReadonlyArray
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<readonly A[]>
Example
import * as S from 'fp-ts/string'
import { getEq } from 'fp-ts/ReadonlyArray'
const E = getEq(S.Eq)
assert.strictEqual(E.equals(['a', 'b'], ['a', 'b']), true)
assert.strictEqual(E.equals(['a'], []), false)
Added in v2.5.0
Signature
export declare const getIntersectionSemigroup: <A>(E: Eq<A>) => Semigroup<readonly A[]>
Added in v2.11.0
Returns a Monoid
for ReadonlyArray<A>
.
Signature
export declare const getMonoid: <A = never>() => Monoid<readonly A[]>
Example
import { getMonoid } from 'fp-ts/ReadonlyArray'
const M = getMonoid<number>()
assert.deepStrictEqual(M.concat([1, 2], [3, 4]), [1, 2, 3, 4])
Added in v2.5.0
Derives an Ord
over the ReadonlyArray
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<readonly A[]>
Example
import { getOrd } from 'fp-ts/ReadonlyArray'
import * as S from 'fp-ts/string'
const O = getOrd(S.Ord)
assert.strictEqual(O.compare(['b'], ['a']), 1)
assert.strictEqual(O.compare(['a'], ['a']), 0)
assert.strictEqual(O.compare(['a'], ['b']), -1)
Added in v2.5.0
Signature
export declare const getSemigroup: <A = never>() => Semigroup<readonly A[]>
Added in v2.5.0
Signature
export declare const getShow: <A>(S: Show<A>) => Show<readonly A[]>
Added in v2.5.0
Signature
export declare const getUnionMonoid: <A>(E: Eq<A>) => Monoid<readonly A[]>
Added in v2.11.0
Signature
export declare const getUnionSemigroup: <A>(E: Eq<A>) => Semigroup<readonly A[]>
Added in v2.11.0
Use small, specific instances instead.
Signature
export declare const readonlyArray: FunctorWithIndex1<'ReadonlyArray', number> &
Monad1<'ReadonlyArray'> &
Unfoldable1<'ReadonlyArray'> &
Alternative1<'ReadonlyArray'> &
Extend1<'ReadonlyArray'> &
FilterableWithIndex1<'ReadonlyArray', number> &
FoldableWithIndex1<'ReadonlyArray', number> &
TraversableWithIndex1<'ReadonlyArray', number> &
Witherable1<'ReadonlyArray'>
Added in v2.5.0
Signature
export declare const fromArray: <A>(as: A[]) => readonly A[]
Added in v2.5.0
Signature
export declare const toArray: <A>(as: readonly A[]) => A[]
Added in v2.5.0
Transforms an Either
to a ReadonlyArray
.
Signature
export declare const fromEither: NaturalTransformation21<'Either', 'ReadonlyArray'>
Added in v2.11.0
Signature
export declare const fromOption: NaturalTransformation11<'Option', 'ReadonlyArray'>
Added in v2.11.0
Test whether a ReadonlyArray
is empty.
Signature
export declare const isEmpty: <A>(as: readonly A[]) => as is readonly []
Example
import { isEmpty } from 'fp-ts/ReadonlyArray'
assert.strictEqual(isEmpty([]), true)
Added in v2.5.0
Test whether a ReadonlyArray
is non empty.
Signature
export declare const isNonEmpty: <A>(as: readonly A[]) => as is RNEA.ReadonlyNonEmptyArray<A>
Added in v2.5.0
Signature
export declare const unsafeDeleteAt: <A>(i: number, as: readonly A[]) => readonly A[]
Added in v2.5.0
Signature
export declare const unsafeInsertAt: <A>(i: number, a: A, as: readonly A[]) => RNEA.ReadonlyNonEmptyArray<A>
Added in v2.5.0
Signature
export declare const unsafeUpdateAt: <A>(i: number, a: A, as: readonly A[]) => readonly A[]
Added in v2.5.0
Signature
export declare const Do: readonly {}[]
Added in v2.9.0
Signature
export interface Spanned<I, R> {
readonly init: ReadonlyArray<I>
readonly rest: ReadonlyArray<R>
}
Added in v2.5.0
Signature
export declare const apS: <N, A, B>(
name: Exclude<N, keyof A>,
fb: readonly B[]
) => (fa: readonly A[]) => readonly { readonly [K in N | keyof A]: K extends keyof A ? A[K] : B }[]
Added in v2.8.0
Signature
export declare const bind: <N, A, B>(
name: Exclude<N, keyof A>,
f: (a: A) => readonly B[]
) => (ma: readonly A[]) => readonly { readonly [K in N | keyof A]: K extends keyof A ? A[K] : B }[]
Added in v2.8.0
Signature
export declare const bindTo: <N>(name: N) => <A>(fa: readonly A[]) => readonly { readonly [K in N]: A }[]
Added in v2.8.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: readonly A[]) => Option<readonly A[]>
Example
import { deleteAt } from 'fp-ts/ReadonlyArray'
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.5.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 ReadonlyArray<A>
.
Signature
export declare function elem<A>(
E: Eq<A>
): {
(a: A): (as: ReadonlyArray<A>) => boolean
(a: A, as: ReadonlyArray<A>): boolean
}
Example
import { elem } from 'fp-ts/ReadonlyArray'
import * as N from 'fp-ts/number'
import { pipe } from 'fp-ts/function'
assert.strictEqual(pipe([1, 2, 3], elem(N.Eq)(2)), true)
assert.strictEqual(pipe([1, 2, 3], elem(N.Eq)(0)), false)
Added in v2.5.0
An empty array
Signature
export declare const empty: readonly never[]
Added in v2.5.0
Check if a predicate holds true for every array member.
Signature
export declare function every<A, B extends A>(
refinement: Refinement<A, B>
): Refinement<ReadonlyArray<A>, ReadonlyArray<B>>
export declare function every<A>(predicate: Predicate<A>): Predicate<ReadonlyArray<A>>
Example
import { every } from 'fp-ts/ReadonlyArray'
import { pipe } from 'fp-ts/function'
const isPositive = (n: number): boolean => n > 0
assert.deepStrictEqual(pipe([1, 2, 3], every(isPositive)), true)
assert.deepStrictEqual(pipe([1, 2, -3], every(isPositive)), false)
Added in v2.9.0
Alias of some
Signature
export declare const exists: <A>(predicate: Predicate<A>) => (as: readonly A[]) => as is RNEA.ReadonlyNonEmptyArray<A>
Added in v2.11.0
Filter values inside a context.
Signature
export declare const filterE: FilterE1<'ReadonlyArray'>
Example
import { pipe } from 'fp-ts/function'
import * as RA from 'fp-ts/ReadonlyArray'
import * as T from 'fp-ts/Task'
const filterE = RA.filterE(T.ApplicativePar)
async function test() {
assert.deepStrictEqual(
await pipe(
[-1, 2, 3],
filterE((n) => T.of(n > 0))
)(),
[2, 3]
)
}
test()
Added in v2.11.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: ReadonlyArray<A>) => Option<B>
export declare function findFirst<A>(predicate: Predicate<A>): <B extends A>(bs: ReadonlyArray<B>) => Option<B>
export declare function findFirst<A>(predicate: Predicate<A>): (as: ReadonlyArray<A>) => Option<A>
Example
import { findFirst } from 'fp-ts/ReadonlyArray'
import { some } from 'fp-ts/Option'
type X = {
readonly a: number
readonly b: number
}
assert.deepStrictEqual(
findFirst((x: X) => x.a === 1)([
{ a: 1, b: 1 },
{ a: 1, b: 2 },
]),
some({ a: 1, b: 1 })
)
Added in v2.5.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: readonly A[]) => Option<B>
Example
import { findFirstMap } from 'fp-ts/ReadonlyArray'
import { some, none } from 'fp-ts/Option'
interface Person {
readonly name: string
readonly age?: number
}
const persons: ReadonlyArray<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.5.0
Find the first index for which a predicate holds
Signature
export declare const findIndex: <A>(predicate: Predicate<A>) => (as: readonly A[]) => Option<number>
Example
import { findIndex } from 'fp-ts/ReadonlyArray'
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.5.0
Find the last element which satisfies a predicate function
Signature
export declare function findLast<A, B extends A>(refinement: Refinement<A, B>): (as: ReadonlyArray<A>) => Option<B>
export declare function findLast<A>(predicate: Predicate<A>): <B extends A>(bs: ReadonlyArray<B>) => Option<B>
export declare function findLast<A>(predicate: Predicate<A>): (as: ReadonlyArray<A>) => Option<A>
Example
import { findLast } from 'fp-ts/ReadonlyArray'
import { some } from 'fp-ts/Option'
type X = {
readonly a: number
readonly b: number
}
assert.deepStrictEqual(
findLast((x: X) => x.a === 1)([
{ a: 1, b: 1 },
{ a: 1, b: 2 },
]),
some({ a: 1, b: 2 })
)
Added in v2.5.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: readonly A[]) => Option<number>
Example
import { findLastIndex } from 'fp-ts/ReadonlyArray'
import { some, none } from 'fp-ts/Option'
interface X {
readonly a: number
readonly b: number
}
const xs: ReadonlyArray<X> = [
{ a: 1, b: 0 },
{ a: 1, b: 1 },
]
assert.deepStrictEqual(findLastIndex((x: { readonly a: number }) => x.a === 1)(xs), some(1))
assert.deepStrictEqual(findLastIndex((x: { readonly a: number }) => x.a === 4)(xs), none)
Added in v2.5.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: readonly A[]) => Option<B>
Example
import { findLastMap } from 'fp-ts/ReadonlyArray'
import { some, none } from 'fp-ts/Option'
interface Person {
readonly name: string
readonly age?: number
}
const persons: ReadonlyArray<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.5.0
Get the first element in an array, or None
if the array is empty
Signature
export declare const head: <A>(as: readonly A[]) => Option<A>
Example
import { head } from 'fp-ts/ReadonlyArray'
import { some, none } from 'fp-ts/Option'
assert.deepStrictEqual(head([1, 2, 3]), some(1))
assert.deepStrictEqual(head([]), none)
Added in v2.5.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: readonly A[]) => Option<readonly A[]>
Example
import { init } from 'fp-ts/ReadonlyArray'
import { some, none } from 'fp-ts/Option'
assert.deepStrictEqual(init([1, 2, 3]), some([1, 2]))
assert.deepStrictEqual(init([]), none)
Added in v2.5.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: readonly A[]) => Option<RNEA.ReadonlyNonEmptyArray<A>>
Example
import { insertAt } from 'fp-ts/ReadonlyArray'
import { some } from 'fp-ts/Option'
assert.deepStrictEqual(insertAt(2, 5)([1, 2, 3, 4]), some([1, 2, 5, 3, 4]))
Added in v2.5.0
Places an element in between members of a ReadonlyArray
, then folds the results using the provided Monoid
.
Signature
export declare const intercalate: <A>(M: Monoid<A>) => (middle: A) => (as: readonly A[]) => A
Example
import * as S from 'fp-ts/string'
import { intercalate } from 'fp-ts/Array'
assert.deepStrictEqual(intercalate(S.Monoid)('-')(['a', 'b', 'c']), 'a-b-c')
Added in v2.12.0
Test whether an array contains a particular index
Signature
export declare const isOutOfBound: <A>(i: number, as: readonly A[]) => boolean
Added in v2.5.0
Get the last element in an array, or None
if the array is empty
Signature
export declare const last: <A>(as: readonly A[]) => Option<A>
Example
import { last } from 'fp-ts/ReadonlyArray'
import { some, none } from 'fp-ts/Option'
assert.deepStrictEqual(last([1, 2, 3]), some(3))
assert.deepStrictEqual(last([]), none)
Added in v2.5.0
This function provides a safe way to read a value at a particular index from an array
Signature
export declare function lookup(i: number): <A>(as: ReadonlyArray<A>) => Option<A>
export declare function lookup<A>(i: number, as: ReadonlyArray<A>): Option<A>
Example
import { lookup } from 'fp-ts/ReadonlyArray'
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.5.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: readonly A[]) => Option<readonly A[]>
Example
import { modifyAt } from 'fp-ts/ReadonlyArray'
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.5.0
Calculate the number of elements in a ReadonlyArray
.
Signature
export declare const size: <A>(as: readonly A[]) => number
Added in v2.10.0
Check if a predicate holds true for any array member.
Signature
export declare const some: <A>(predicate: Predicate<A>) => (as: readonly A[]) => as is RNEA.ReadonlyNonEmptyArray<A>
Example
import { some } from 'fp-ts/ReadonlyArray'
import { pipe } from 'fp-ts/function'
const isPositive = (n: number): boolean => n > 0
assert.deepStrictEqual(pipe([-1, -2, 3], some(isPositive)), true)
assert.deepStrictEqual(pipe([-1, -2, -3], some(isPositive)), false)
Added in v2.9.0
Split an array into two parts:
- the longest initial subarray for which all elements satisfy the specified predicate
- the remaining elements
Signature
export declare function spanLeft<A, B extends A>(refinement: Refinement<A, B>): (as: ReadonlyArray<A>) => Spanned<B, A>
export declare function spanLeft<A>(predicate: Predicate<A>): <B extends A>(bs: ReadonlyArray<B>) => Spanned<B, B>
export declare function spanLeft<A>(predicate: Predicate<A>): (as: ReadonlyArray<A>) => Spanned<A, A>
Example
import { spanLeft } from 'fp-ts/ReadonlyArray'
assert.deepStrictEqual(spanLeft((n: number) => n % 2 === 1)([1, 3, 2, 4, 5]), { init: [1, 3], rest: [2, 4, 5] })
Added in v2.5.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: readonly A[]) => Option<readonly A[]>
Example
import { tail } from 'fp-ts/ReadonlyArray'
import { some, none } from 'fp-ts/Option'
assert.deepStrictEqual(tail([1, 2, 3]), some([2, 3]))
assert.deepStrictEqual(tail([]), none)
Added in v2.5.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: readonly A[]) => Option<readonly A[]>
Example
import { updateAt } from 'fp-ts/ReadonlyArray'
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.5.0