/**

* @since 2.5.0

*/

import { Alt1 } from './Alt'

import { Alternative1 } from './Alternative'

import { Applicative as ApplicativeHKT, Applicative1 } from './Applicative'

import { apFirst as apFirst_, Apply1, apS as apS_, apSecond as apSecond_ } from './Apply'

import { bind as bind_, Chain1, chainFirst as chainFirst_ } from './Chain'

import { ChainRec1 } from './ChainRec'

import { Compactable1 } from './Compactable'

import { Either } from './Either'

import { Eq, fromEquals } from './Eq'

import { Extend1 } from './Extend'

import { Filterable1 } from './Filterable'

import { FilterableWithIndex1, PredicateWithIndex, RefinementWithIndex } from './FilterableWithIndex'

import { Foldable1 } from './Foldable'

import { FoldableWithIndex1 } from './FoldableWithIndex'

import { FromEither1, fromEitherK as fromEitherK_ } from './FromEither'

import { dual, identity, LazyArg, pipe } from './function'

import { bindTo as bindTo_, flap as flap_, Functor1, let as let__ } from './Functor'

import { FunctorWithIndex1 } from './FunctorWithIndex'

import { HKT } from './HKT'

import * as _ from './internal'

import { Magma } from './Magma'

import { Monad1 } from './Monad'

import { Monoid } from './Monoid'

import { NonEmptyArray } from './NonEmptyArray'

import * as N from './number'

import { Option } from './Option'

import { fromCompare, Ord } from './Ord'

import { Pointed1 } from './Pointed'

import { Predicate } from './Predicate'

import * as RNEA from './ReadonlyNonEmptyArray'

import { Refinement } from './Refinement'

import { Semigroup } from './Semigroup'

import { Separated, separated } from './Separated'

import { Show } from './Show'

import { PipeableTraverse1, Traversable1 } from './Traversable'

import { PipeableTraverseWithIndex1, TraversableWithIndex1 } from './TraversableWithIndex'

import { Unfoldable1 } from './Unfoldable'

import {

filterE as filterE_,

PipeableWilt1,

PipeableWither1,

wiltDefault,

Witherable1,

witherDefault

} from './Witherable'

import { guard as guard_, Zero1 } from './Zero'

import ReadonlyNonEmptyArray = RNEA.ReadonlyNonEmptyArray

// -------------------------------------------------------------------------------------

// refinements

// -------------------------------------------------------------------------------------

/**

* Test whether a `ReadonlyArray` is empty.

*

* @example

* import { isEmpty } from 'fp-ts/ReadonlyArray'

*

* assert.strictEqual(isEmpty([]), true)

*

* @category refinements

* @since 2.5.0

*/

export const isEmpty = <A>(as: ReadonlyArray<A>): as is readonly [] => as.length === 0

/**

* Test whether a `ReadonlyArray` is non empty.

*

* @category refinements

* @since 2.5.0

*/

export const isNonEmpty: <A>(as: ReadonlyArray<A>) => as is ReadonlyNonEmptyArray<A> = RNEA.isNonEmpty

// -------------------------------------------------------------------------------------

// constructors

// -------------------------------------------------------------------------------------

/**

* Prepend an element to the front of a `ReadonlyArray`, creating a new `ReadonlyNonEmptyArray`.

*

* @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])

*

* @since 2.10.0

*/

export const prepend = RNEA.prepend

/**

* Less strict version of [`prepend`](#prepend).

*

* @since 2.11.0

*/

export const prependW = RNEA.prependW

/**

* Append an element to the end of a `ReadonlyArray`, creating a new `ReadonlyNonEmptyArray`.

*

* @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])

*

* @since 2.10.0

*/

export const append = RNEA.append

/**

* Less strict version of [`append`](#append).

*

* @since 2.11.0

*/

export const appendW = RNEA.appendW

/**

* Return a `ReadonlyArray` of length `n` with element `i` initialized with `f(i)`.

*

* **Note**. `n` is normalized to a non negative integer.

*

* @example

* import { makeBy } from 'fp-ts/ReadonlyArray'

*

* const double = (n: number): number => n * 2

* assert.deepStrictEqual(makeBy(5, double), [0, 2, 4, 6, 8])

*

* @category constructors

* @since 2.5.0

*/

export const makeBy = <A>(n: number, f: (i: number) => A): ReadonlyArray<A> => (n <= 0 ? empty : RNEA.makeBy(f)(n))

/**

* Create a `ReadonlyArray` containing a value repeated the specified number of times.

*

* **Note**. `n` is normalized to a non negative integer.

*

* @example

* import { replicate } from 'fp-ts/ReadonlyArray'

*

* assert.deepStrictEqual(replicate(3, 'a'), ['a', 'a', 'a'])

*

* @category constructors

* @since 2.5.0

*/

export const replicate = <A>(n: number, a: A): ReadonlyArray<A> => makeBy(n, () => a)

/**

* @category lifting

* @since 2.11.0

*/

export function fromPredicate<A, B extends A>(refinement: Refinement<A, B>): (a: A) => ReadonlyArray<B>

export function fromPredicate<A>(predicate: Predicate<A>): <B extends A>(b: B) => ReadonlyArray<B>

export function fromPredicate<A>(predicate: Predicate<A>): (a: A) => ReadonlyArray<A>

export function fromPredicate<A>(predicate: Predicate<A>): (a: A) => ReadonlyArray<A> {

return (a) => (predicate(a) ? [a] : empty)

}

// -------------------------------------------------------------------------------------

// conversions

// -------------------------------------------------------------------------------------

/**

* @category conversions

* @since 2.11.0

*/

export const fromOption: <A>(fa: Option<A>) => ReadonlyArray<A> = (ma) => (_.isNone(ma) ? empty : [ma.value])

/**

* Transforms an `Either` to a `ReadonlyArray`.

*

* @category conversions

* @since 2.11.0

*/

export const fromEither: <A>(fa: Either<unknown, A>) => ReadonlyArray<A> = (e) => (_.isLeft(e) ? empty : [e.right])

/**

* Less strict version of [`match`](#match).

*

* The `W` suffix (short for **W**idening) means that the handler return types will be merged.

*

* @category pattern matching

* @since 2.11.0

*/

export const matchW =

<B, A, C>(onEmpty: LazyArg<B>, onNonEmpty: (as: ReadonlyNonEmptyArray<A>) => C) =>

(as: ReadonlyArray<A>): B | C =>

isNonEmpty(as) ? onNonEmpty(as) : onEmpty()

/**

* @category pattern matching

* @since 2.11.0

*/

export const match: <B, A>(

onEmpty: LazyArg<B>,

onNonEmpty: (as: ReadonlyNonEmptyArray<A>) => B

) => (as: ReadonlyArray<A>) => B = matchW

/**

* Less strict version of [`matchLeft`](#matchleft).

*

* @category pattern matching

* @since 2.11.0

*/

export const matchLeftW =

<B, A, C>(onEmpty: LazyArg<B>, onNonEmpty: (head: A, tail: ReadonlyArray<A>) => C) =>

(as: ReadonlyArray<A>): B | C =>

isNonEmpty(as) ? onNonEmpty(RNEA.head(as), RNEA.tail(as)) : onEmpty()

/**

* Break a `ReadonlyArray` into its first element and remaining elements.

*

* @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)

*

* @category pattern matching

* @since 2.10.0

*/

export const matchLeft: <B, A>(

onEmpty: LazyArg<B>,

onNonEmpty: (head: A, tail: ReadonlyArray<A>) => B

) => (as: ReadonlyArray<A>) => B = matchLeftW

/**

* Alias of [`matchLeft`](#matchleft).

*

* @category pattern matching

* @since 2.5.0

*/

export const foldLeft: <A, B>(

onEmpty: LazyArg<B>,

onNonEmpty: (head: A, tail: ReadonlyArray<A>) => B

) => (as: ReadonlyArray<A>) => B = matchLeft

/**

* Less strict version of [`matchRight`](#matchright).

*

* @category pattern matching

* @since 2.11.0

*/

export const matchRightW =

<B, A, C>(onEmpty: LazyArg<B>, onNonEmpty: (init: ReadonlyArray<A>, last: A) => C) =>

(as: ReadonlyArray<A>): B | C =>

isNonEmpty(as) ? onNonEmpty(RNEA.init(as), RNEA.last(as)) : onEmpty()

/**

* Break a `ReadonlyArray` into its initial elements and the last element.

*

* @category pattern matching

* @since 2.10.0

*/

export const matchRight: <B, A>(

onEmpty: LazyArg<B>,

onNonEmpty: (init: ReadonlyArray<A>, last: A) => B

) => (as: ReadonlyArray<A>) => B = matchRightW

/**

* Alias of [`matchRight`](#matchright).

*

* @category pattern matching

* @since 2.5.0

*/

export const foldRight: <A, B>(

onEmpty: LazyArg<B>,

onNonEmpty: (init: ReadonlyArray<A>, last: A) => B

) => (as: ReadonlyArray<A>) => B = matchRight

// -------------------------------------------------------------------------------------

// combinators

// -------------------------------------------------------------------------------------

/**

* @category sequencing

* @since 2.7.0

*/

export const chainWithIndex =

<A, B>(f: (i: number, a: A) => ReadonlyArray<B>) =>

(as: ReadonlyArray<A>): ReadonlyArray<B> => {

if (isEmpty(as)) {

return empty

}

const out: Array<B> = []

for (let i = 0; i < as.length; i++) {

out.push(...f(i, as[i]))

}

return out

}

/**

* Same as `reduce` but it carries over the intermediate steps.

*

* @example

* import { scanLeft } from 'fp-ts/ReadonlyArray'

*

* assert.deepStrictEqual(scanLeft(10, (b, a: number) => b - a)([1, 2, 3]), [10, 9, 7, 4])

*

* @since 2.5.0

*/

export const scanLeft =

<A, B>(b: B, f: (b: B, a: A) => B) =>

(as: ReadonlyArray<A>): ReadonlyNonEmptyArray<B> => {

const len = as.length

const out = new Array(len + 1) as NonEmptyArray<B>

out[0] = b

for (let i = 0; i < len; i++) {

out[i + 1] = f(out[i], as[i])

}

return out

}

/**

* Fold an array from the right, keeping all intermediate results instead of only the final result

*

* @example

* import { scanRight } from 'fp-ts/ReadonlyArray'

*

* assert.deepStrictEqual(scanRight(10, (a: number, b) => b - a)([1, 2, 3]), [4, 5, 7, 10])

*

* @since 2.5.0

*/

export const scanRight =

<A, B>(b: B, f: (a: A, b: B) => B) =>

(as: ReadonlyArray<A>): ReadonlyNonEmptyArray<B> => {

const len = as.length

const out = new Array(len + 1) as NonEmptyArray<B>

out[len] = b

for (let i = len - 1; i >= 0; i--) {

out[i] = f(as[i], out[i + 1])

}

return out

}

/**

* Calculate the number of elements in a `ReadonlyArray`.

*

* @since 2.10.0

*/

export const size = <A>(as: ReadonlyArray<A>): number => as.length

/**

* Test whether an array contains a particular index

*

* @since 2.5.0

*/

export const isOutOfBound: <A>(i: number, as: ReadonlyArray<A>) => boolean = RNEA.isOutOfBound

// TODO: remove non-curried overloading in v3

/**

* This function provides a safe way to read a value at a particular index from an array

*

* @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)

*

* @since 2.5.0

*/

export function lookup(i: number): <A>(as: ReadonlyArray<A>) => Option<A>

export function lookup<A>(i: number, as: ReadonlyArray<A>): Option<A>

export function lookup<A>(i: number, as?: ReadonlyArray<A>): Option<A> | (<A>(as: ReadonlyArray<A>) => Option<A>) {

return as === undefined ? (as) => lookup(i, as) : isOutOfBound(i, as) ? _.none : _.some(as[i])

}

/**

* Get the first element in an array, or `None` if the array is empty

*

* @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)

*

* @since 2.5.0

*/

export const head = <A>(as: ReadonlyArray<A>): Option<A> => (isNonEmpty(as) ? _.some(RNEA.head(as)) : _.none)

/**

* Get the last element in an array, or `None` if the array is empty

*

* @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)

*

* @since 2.5.0

*/

export const last = <A>(as: ReadonlyArray<A>): Option<A> => (isNonEmpty(as) ? _.some(RNEA.last(as)) : _.none)

/**

* Get all but the first element of an array, creating a new array, or `None` if the array is empty

*

* @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)

*

* @since 2.5.0

*/

export const tail = <A>(as: ReadonlyArray<A>): Option<ReadonlyArray<A>> =>

isNonEmpty(as) ? _.some(RNEA.tail(as)) : _.none

/**

* Get all but the last element of an array, creating a new array, or `None` if the array is empty

*

* @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)

*

* @since 2.5.0

*/

export const init = <A>(as: ReadonlyArray<A>): Option<ReadonlyArray<A>> =>

isNonEmpty(as) ? _.some(RNEA.init(as)) : _.none

/**

* 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.

*

* @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)

*

* @since 2.5.0

*/

export const takeLeft =

(n: number) =>

<A>(as: ReadonlyArray<A>): ReadonlyArray<A> =>

isOutOfBound(n, as) ? as : n === 0 ? empty : as.slice(0, n)

/**

* 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.

*

* @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)

*

* @since 2.5.0

*/

export const takeRight =

(n: number) =>

<A>(as: ReadonlyArray<A>): ReadonlyArray<A> =>

isOutOfBound(n, as) ? as : n === 0 ? empty : as.slice(-n)

/**

* Calculate the longest initial subarray for which all element satisfy the specified predicate, creating a new array

*

* @example

* import { takeLeftWhile } from 'fp-ts/ReadonlyArray'

*

* assert.deepStrictEqual(takeLeftWhile((n: number) => n % 2 === 0)([2, 4, 3, 6]), [2, 4])

*

* @since 2.5.0

*/

export function takeLeftWhile<A, B extends A>(refinement: Refinement<A, B>): (as: ReadonlyArray<A>) => ReadonlyArray<B>

export function takeLeftWhile<A>(predicate: Predicate<A>): <B extends A>(bs: ReadonlyArray<B>) => ReadonlyArray<B>

export function takeLeftWhile<A>(predicate: Predicate<A>): (as: ReadonlyArray<A>) => ReadonlyArray<A>

export function takeLeftWhile<A>(predicate: Predicate<A>): (as: ReadonlyArray<A>) => ReadonlyArray<A> {

return (as: ReadonlyArray<A>) => {

const out: Array<A> = []

for (const a of as) {

if (!predicate(a)) {

break

}

out.push(a)

}

const len = out.length

return len === as.length ? as : len === 0 ? empty : out

}

}

/**

* @since 2.5.0

*/

export interface Spanned<I, R> {

readonly init: ReadonlyArray<I>

readonly rest: ReadonlyArray<R>

}

const spanLeftIndex = <A>(as: ReadonlyArray<A>, predicate: Predicate<A>): number => {

const l = as.length

let i = 0

for (; i < l; i++) {

if (!predicate(as[i])) {

break

}

}

return i

}

/**

* Split an array into two parts:

* 1. the longest initial subarray for which all elements satisfy the specified predicate

* 2. the remaining elements

*

* @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] })

*

* @since 2.5.0

*/

export function spanLeft<A, B extends A>(refinement: Refinement<A, B>): (as: ReadonlyArray<A>) => Spanned<B, A>

export function spanLeft<A>(predicate: Predicate<A>): <B extends A>(bs: ReadonlyArray<B>) => Spanned<B, B>

export function spanLeft<A>(predicate: Predicate<A>): (as: ReadonlyArray<A>) => Spanned<A, A>

export function spanLeft<A>(predicate: Predicate<A>): (as: ReadonlyArray<A>) => Spanned<A, A> {

return (as) => {

const [init, rest] = splitAt(spanLeftIndex(as, predicate))(as)

return { init, rest }

}

}

/**

* 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.

*

* @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)

*

* @since 2.5.0

*/

export const dropLeft =

(n: number) =>

<A>(as: ReadonlyArray<A>): ReadonlyArray<A> =>

n <= 0 || isEmpty(as) ? as : n >= as.length ? empty : as.slice(n, as.length)

/**

* 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.

*

* @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)

*

* @since 2.5.0

*/

export const dropRight =

(n: number) =>

<A>(as: ReadonlyArray<A>): ReadonlyArray<A> =>

n <= 0 || isEmpty(as) ? as : n >= as.length ? empty : as.slice(0, as.length - n)

/**

* Remove the longest initial subarray for which all element satisfy the specified predicate, creating a new array

*

* @example

* import { dropLeftWhile } from 'fp-ts/ReadonlyArray'

*

* assert.deepStrictEqual(dropLeftWhile((n: number) => n % 2 === 1)([1, 3, 2, 4, 5]), [2, 4, 5])

*

* @since 2.5.0

*/

export function dropLeftWhile<A, B extends A>(refinement: Refinement<A, B>): (as: ReadonlyArray<A>) => ReadonlyArray<B>

export function dropLeftWhile<A>(predicate: Predicate<A>): <B extends A>(bs: ReadonlyArray<B>) => ReadonlyArray<B>

export function dropLeftWhile<A>(predicate: Predicate<A>): (as: ReadonlyArray<A>) => ReadonlyArray<A>

export function dropLeftWhile<A>(predicate: Predicate<A>): (as: ReadonlyArray<A>) => ReadonlyArray<A> {

return (as) => {

const i = spanLeftIndex(as, predicate)

return i === 0 ? as : i === as.length ? empty : as.slice(i)

}

}

/**

* Find the first index for which a predicate holds

*

* @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)

*

* @since 2.5.0

*/

export const findIndex =

<A>(predicate: Predicate<A>) =>

(as: ReadonlyArray<A>): Option<number> => {

for (let i = 0; i < as.length; i++) {

if (predicate(as[i])) {

return _.some(i)

}

}

return _.none

}

/**

* Find the first element which satisfies a predicate (or a refinement) function

*

* @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 }))

*

* @since 2.5.0

*/

export function findFirst<A, B extends A>(refinement: Refinement<A, B>): (as: ReadonlyArray<A>) => Option<B>

export function findFirst<A>(predicate: Predicate<A>): <B extends A>(bs: ReadonlyArray<B>) => Option<B>

export function findFirst<A>(predicate: Predicate<A>): (as: ReadonlyArray<A>) => Option<A>

export function findFirst<A>(predicate: Predicate<A>): (as: ReadonlyArray<A>) => Option<A> {

return (as) => {

for (let i = 0; i < as.length; i++) {

if (predicate(as[i])) {

return _.some(as[i])

}

}

return _.none

}

}

/**

* Find the first element returned by an option based selector function

*

* @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'))

*

* @since 2.5.0

*/

export const findFirstMap =

<A, B>(f: (a: A) => Option<B>) =>

(as: ReadonlyArray<A>): Option<B> => {

for (let i = 0; i < as.length; i++) {

const out = f(as[i])

if (_.isSome(out)) {

return out

}

}

return _.none

}

/**

* Find the last element which satisfies a predicate function

*

* @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 }))

*

* @since 2.5.0

*/

export function findLast<A, B extends A>(refinement: Refinement<A, B>): (as: ReadonlyArray<A>) => Option<B>

export function findLast<A>(predicate: Predicate<A>): <B extends A>(bs: ReadonlyArray<B>) => Option<B>

export function findLast<A>(predicate: Predicate<A>): (as: ReadonlyArray<A>) => Option<A>

export function findLast<A>(predicate: Predicate<A>): (as: ReadonlyArray<A>) => Option<A> {

return (as) => {

for (let i = as.length - 1; i >= 0; i--) {

if (predicate(as[i])) {

return _.some(as[i])

}

}

return _.none

}

}

/**

* Find the last element returned by an option based selector function

*

* @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'))

*

* @since 2.5.0

*/

export const findLastMap =

<A, B>(f: (a: A) => Option<B>) =>

(as: ReadonlyArray<A>): Option<B> => {

for (let i = as.length - 1; i >= 0; i--) {

const out = f(as[i])

if (_.isSome(out)) {

return out

}

}

return _.none

}

/**

* Returns the index of the last element of the list which matches the predicate

*

* @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)

*

*

* @since 2.5.0

*/

export const findLastIndex =

<A>(predicate: Predicate<A>) =>

(as: ReadonlyArray<A>): Option<number> => {

for (let i = as.length - 1; i >= 0; i--) {

if (predicate(as[i])) {

return _.some(i)

}

}

return _.none

}

/**

* Insert an element at the specified index, creating a new array, or returning `None` if the index is out of bounds

*

* @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]))

*

* @since 2.5.0

*/

export const insertAt =

<A>(i: number, a: A) =>

(as: ReadonlyArray<A>): Option<ReadonlyNonEmptyArray<A>> =>

i < 0 || i > as.length ? _.none : _.some(RNEA.unsafeInsertAt(i, a, as))

/**

* Change the element at the specified index, creating a new array, or returning `None` if the index is out of bounds

*

* @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)

*

* @since 2.5.0

*/

export const updateAt = <A>(i: number, a: A): ((as: ReadonlyArray<A>) => Option<ReadonlyArray<A>>) =>

modifyAt(i, () => a)

/**

* Delete the element at the specified index, creating a new array, or returning `None` if the index is out of bounds

*

* @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)

*

* @since 2.5.0

*/

export const deleteAt =

(i: number) =>

<A>(as: ReadonlyArray<A>): Option<ReadonlyArray<A>> =>

isOutOfBound(i, as) ? _.none : _.some(unsafeDeleteAt(i, as))

/**

* Apply a function to the element at the specified index, creating a new array, or returning `None` if the index is out

* of bounds

*

* @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)

*

* @since 2.5.0

*/

export const modifyAt =

<A>(i: number, f: (a: A) => A) =>

(as: ReadonlyArray<A>): Option<ReadonlyArray<A>> =>

isOutOfBound(i, as) ? _.none : _.some(unsafeUpdateAt(i, f(as[i]), as))

/**

* Reverse an array, creating a new array

*

* @example

* import { reverse } from 'fp-ts/ReadonlyArray'

*

* assert.deepStrictEqual(reverse([1, 2, 3]), [3, 2, 1])

*

* @since 2.5.0

*/

export const reverse = <A>(as: ReadonlyArray<A>): ReadonlyArray<A> => (as.length <= 1 ? as : as.slice().reverse())

/**

* Extracts from an array of `Either` all the `Right` elements. All the `Right` elements are extracted in order

*

* @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])

*

* @since 2.5.0

*/

export const rights = <E, A>(as: ReadonlyArray<Either<E, A>>): ReadonlyArray<A> => {

const r: Array<A> = []

for (let i = 0; i < as.length; i++) {

const a = as[i]

if (a._tag === 'Right') {

r.push(a.right)

}

}

return r

}

/**

* Extracts from an array of `Either` all the `Left` elements. All the `Left` elements are extracted in order

*

* @example

* import { lefts } from 'fp-ts/ReadonlyArray'

* import { left, right } from 'fp-ts/Either'

*

* assert.deepStrictEqual(lefts([right(1), left('foo'), right(2)]), ['foo'])

*

* @since 2.5.0

*/

export const lefts = <E, A>(as: ReadonlyArray<Either<E, A>>): ReadonlyArray<E> => {

const r: Array<E> = []

for (let i = 0; i < as.length; i++) {

const a = as[i]

if (a._tag === 'Left') {

r.push(a.left)

}

}

return r

}

/**

* Sort the elements of an array in increasing order, creating a new array

*

* @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])

*

* @since 2.5.0

*/

export const sort =

<B>(O: Ord<B>) =>

<A extends B>(as: ReadonlyArray<A>): ReadonlyArray<A> =>

as.length <= 1 ? as : as.slice().sort(O.compare)

// TODO: curry and make data-last in v3

/**

* 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.

*

* @example

* import { zipWith } from 'fp-ts/ReadonlyArray'

*

* assert.deepStrictEqual(zipWith([1, 2, 3], ['a', 'b', 'c', 'd'], (n, s) => s + n), ['a1', 'b2', 'c3'])

*

* @since 2.5.0

*/

export const zipWith = <A, B, C>(

fa: ReadonlyArray<A>,

fb: ReadonlyArray<B>,

f: (a: A, b: B) => C

): ReadonlyArray<C> => {

const fc: Array<C> = []

const len = Math.min(fa.length, fb.length)

for (let i = 0; i < len; i++) {

fc[i] = f(fa[i], fb[i])

}

return fc

}

// TODO: remove non-curried overloading in v3

/**

* Takes two arrays and returns an array of corresponding pairs. If one input array is short, excess elements of the

* longer array are discarded

*

* @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']])

*

* @since 2.5.0

*/

export function zip<B>(bs: ReadonlyArray<B>): <A>(as: ReadonlyArray<A>) => ReadonlyArray<readonly [A, B]>

export function zip<A, B>(as: ReadonlyArray<A>, bs: ReadonlyArray<B>): ReadonlyArray<readonly [A, B]>

export function zip<A, B>(

as: ReadonlyArray<A>,

bs?: ReadonlyArray<B>

): ReadonlyArray<readonly [A, B]> | ((bs: ReadonlyArray<B>) => ReadonlyArray<readonly [B, A]>) {

if (bs === undefined) {

return (bs) => zip(bs, as)

}

return zipWith(as, bs, (a, b) => [a, b])

}

/**

* The function is reverse of `zip`. Takes an array of pairs and return two corresponding arrays

*

* @example

* import { unzip } from 'fp-ts/ReadonlyArray'

*

* assert.deepStrictEqual(unzip([[1, 'a'], [2, 'b'], [3, 'c']]), [[1, 2, 3], ['a', 'b', 'c']])

*

* @since 2.5.0

*/

export const unzip = <A, B>(as: ReadonlyArray<readonly [A, B]>): readonly [ReadonlyArray<A>, ReadonlyArray<B>] => {

const fa: Array<A> = []

const fb: Array<B> = []

for (let i = 0; i < as.length; i++) {

fa[i] = as[i][0]

fb[i] = as[i][1]

}

return [fa, fb]

}

/**

* Prepend an element to every member of an array

*

* @example

* import { prependAll } from 'fp-ts/ReadonlyArray'

*

* assert.deepStrictEqual(prependAll(9)([1, 2, 3, 4]), [9, 1, 9, 2, 9, 3, 9, 4])

*

* @since 2.10.0