Arr

const Arr: object

Defined in: Data/Arr.ts:1290

Type Declaration

append

append: <A>(item) => (items) => NonEmptyArr<A>

Appends a value to the end of an array, returning a NonEmptyArr.

Type Parameters

A

A

Parameters

item

A

Returns

(items) => NonEmptyArr<A>

See

prepend for adding an element to the beginning.

Example

pipe([1, 2], Arr.append(3)); // [1, 2, 3]

at

at: (index) => <A>(items) => Maybe<A>

Safely looks up an element by index. Supports negative indices counting back from the end. Returns None if the index is out of bounds.

Parameters

index

number

Returns

<A>(items) => Maybe<A>

Example

pipe([10, 20, 30], Arr.at(1));  // Some(20)
pipe([10, 20, 30], Arr.at(-1)); // Some(30)
pipe([10, 20, 30], Arr.at(5));  // None

chunkBy

chunkBy: <A, K>(keySelector) => (items) => readonly (readonly A[])[]

Groups consecutive elements that share the same key returned by keySelector.

Type Parameters

A

A

K

K

Parameters

keySelector

(item) => K

Returns

(items) => readonly (readonly A[])[]

See

chunksOf for fixed-size chunking.

Example

pipe(
  [1, 1, 2, 3, 3, 1],
  Arr.chunkBy((n) => n)
); // [[1, 1], [2], [3, 3], [1]]

chunksOf

chunksOf: (size) => <A>(items) => readonly (readonly A[])[]

Splits an array into chunks of the given size.

Parameters

size

number

Returns

<A>(items) => readonly (readonly A[])[]

See

chunkBy for grouping consecutive elements sharing a key.

Example

pipe([1, 2, 3, 4, 5], Arr.chunksOf(2)); // [[1, 2], [3, 4], [5]]

compact

compact: <A>(items) => readonly A[]

Narrows a list of Maybe values down to a list of their underlying values, discarding all None instances.

Type Parameters

A

A

Parameters

items

readonly Maybe<A>[]

Returns

readonly A[]

See

separate for dividing Results into error and success arrays.

Example

Arr.compact([Maybe.make.some(1), Maybe.make.none(), Maybe.make.some(3)]); // [1, 3]

concat

concat: <A>(other) => (items) => readonly A[]

Concatenates a standard array with another array.

Type Parameters

A

A

Parameters

other

readonly A[]

Returns

(items) => readonly A[]

Example

pipe([1, 2], Arr.concat([3, 4])); // [1, 2, 3, 4]

dedupeAdjacent

dedupeAdjacent: <A>(areEqual) => (items) => readonly A[]

Removes consecutive duplicate elements. An optional Equality<A> can be provided (defaults to Object.is).

Type Parameters

A

A

Parameters

areEqual?

Equality<A> = ...

Returns

(items) => readonly A[]

See

uniq for deduplicating across the entire array.

Example

Arr.dedupeAdjacent()([1, 1, 2, 2, 1, 3]); // [1, 2, 1, 3]

drop

drop: (count) => <A>(items) => readonly A[]

Drops the first n elements from an array.

Parameters

count

number

Returns

<A>(items) => readonly A[]

See

• take for keeping the first n elements.
• dropWhile for discarding elements based on a predicate.

Example

pipe([1, 2, 3, 4], Arr.drop(2)); // [3, 4]

dropWhile

dropWhile: <A>(predicate) => (items) => readonly A[]

Drops elements from the start while the predicate holds.

Type Parameters

A

A

Parameters

predicate

(item) => boolean

Returns

(items) => readonly A[]

See

• takeWhile for keeping elements while a predicate holds.
• drop for discarding a fixed count of elements.

Example

pipe([1, 2, 3, 1], Arr.dropWhile(n => n < 3)); // [3, 1]

every

every: <A>(predicate) => (items) => boolean

Returns true if all elements satisfy the predicate.

Type Parameters

A

A

Parameters

predicate

(item) => boolean

Returns

(items) => boolean

See

some for checking whether any element satisfies a predicate.

Example

pipe([1, 2, 3], Arr.every(n => n > 0)); // true

filter

filter: {<A, B>(predicate): (items) => readonly B[]; <A>(predicate): (items) => readonly A[]; }

Call Signature

<A, B>(predicate): (items) => readonly B[]

Filters elements that satisfy the predicate.

Type Parameters

A

A

B

B

Parameters

predicate

(item) => item is B

Returns

(items) => readonly B[]

See

filterMap for filtering and mapping simultaneously.

Example

pipe([1, 2, 3, 4], Arr.filter(n => n % 2 === 0)); // [2, 4]

Call Signature

<A>(predicate): (items) => readonly A[]

Filters elements that satisfy the predicate.

Type Parameters

A

A

Parameters

predicate

(item) => boolean

Returns

(items) => readonly A[]

See

filterMap for filtering and mapping simultaneously.

Example

pipe([1, 2, 3, 4], Arr.filter(n => n % 2 === 0)); // [2, 4]

filterMap

filterMap: <A, B>(transform) => (items) => readonly B[]

Maps each element to a Maybe and collects only the Some values. Combines map and filter in a single pass.

Type Parameters

A

A

B

B

Parameters

transform

(item) => Maybe<B>

Returns

(items) => readonly B[]

See

filter for filtering with a boolean predicate.

Example

const parseNum = (s: string): Maybe<number> => {
  const n = Number(s);
  return isNaN(n) ? Maybe.make.none() : Maybe.make.some(n);
};

pipe(["1", "abc", "3"], Arr.filterMap(parseNum)); // [1, 3]

findFirst

findFirst: {<A, B>(predicate): (items) => Maybe<B>; <A>(predicate): (items) => Maybe<A>; }

Call Signature

<A, B>(predicate): (items) => Maybe<B>

Returns the first element matching the predicate, or None.

Type Parameters

A

A

B

B

Parameters

predicate

(item) => item is B

Returns

(items) => Maybe<B>

See

• findLast for finding the last matching element.
• findIndex for obtaining the index of the first matching element.

Example

pipe([1, 2, 3, 4], Arr.findFirst(n => n > 2)); // Some(3)

Call Signature

<A>(predicate): (items) => Maybe<A>

Returns the first element matching the predicate, or None.

Type Parameters

A

A

Parameters

predicate

(item) => boolean

Returns

(items) => Maybe<A>

See

• findLast for finding the last matching element.
• findIndex for obtaining the index of the first matching element.

Example

pipe([1, 2, 3, 4], Arr.findFirst(n => n > 2)); // Some(3)

findIndex

findIndex: <A>(predicate) => (items) => Maybe<number>

Returns the index of the first element matching the predicate, or None.

Type Parameters

A

A

Parameters

predicate

(item) => boolean

Returns

(items) => Maybe<number>

See

findFirst for finding the matching element value.

Example

pipe([1, 2, 3, 4], Arr.findIndex(n => n > 2)); // Some(2)

findLast

findLast: {<A, B>(predicate): (items) => Maybe<B>; <A>(predicate): (items) => Maybe<A>; }

Call Signature

<A, B>(predicate): (items) => Maybe<B>

Returns the last element matching the predicate, or None.

Type Parameters

A

A

B

B

Parameters

predicate

(item) => item is B

Returns

(items) => Maybe<B>

See

findFirst for finding the first matching element.

Example

pipe([1, 2, 3, 4], Arr.findLast(n => n > 2)); // Some(4)

Call Signature

<A>(predicate): (items) => Maybe<A>

Returns the last element matching the predicate, or None.

Type Parameters

A

A

Parameters

predicate

(item) => boolean

Returns

(items) => Maybe<A>

See

findFirst for finding the first matching element.

Example

pipe([1, 2, 3, 4], Arr.findLast(n => n > 2)); // Some(4)

findMap

findMap: <A, B>(transform) => (items) => Maybe<B>

Finds the first element in an array for which transform returns Some(b).

Type Parameters

A

A

B

B

Parameters

transform

(item) => Maybe<B>

Returns

(items) => Maybe<B>

See

findFirst for finding elements with a boolean predicate.

Example

pipe(
  ["1", "a", "2"],
  Arr.findMap((s) => isNaN(Number(s)) ? Maybe.make.none() : Maybe.make.some(Number(s)))
); // Some(1)

flatMap

flatMap: <A, B>(transform) => (items) => readonly B[]

Maps each element to an array and flattens the result.

Type Parameters

A

A

B

B

Parameters

transform

(item) => readonly B[]

Returns

(items) => readonly B[]

See

• map for mapping without flattening.
• flatten for flattening without mapping.

Example

pipe([1, 2, 3], Arr.flatMap(n => [n, n * 10])); // [1, 10, 2, 20, 3, 30]

flatten

flatten: <A>(items) => readonly A[]

Flattens a nested array by one level.

Type Parameters

A

A

Parameters

items

readonly (readonly A[])[]

Returns

readonly A[]

See

flatMap for mapping elements to arrays before flattening.

Example

Arr.flatten([[1, 2], [3], [4, 5]]); // [1, 2, 3, 4, 5]

frequencies

frequencies: <A>(items) => ReadonlyMap<A, number>

Counts occurrences of each element in an array, returning a ReadonlyMap<A, number>.

Type Parameters

A

A

Parameters

items

readonly A[]

Returns

ReadonlyMap<A, number>

Example

Arr.frequencies(["a", "b", "a", "c", "b", "a"]);
// ReadonlyMap { "a" => 3, "b" => 2, "c" => 1 }

groupBy

groupBy: <A>(keySelector) => (items) => Record<string, NonEmptyArr<A>>

Groups elements by a key function.

Type Parameters

A

A

Parameters

keySelector

(item) => string

Returns

(items) => Record<string, NonEmptyArr<A>>

See

indexBy for indexing elements into a Map.

Example

pipe(
  ["apple", "avocado", "banana"],
  Arr.groupBy(s => s[0])
); // { a: ["apple", "avocado"], b: ["banana"] }

head

head: <A>(items) => Maybe<A>

Returns the first element of an array, or None if the array is empty.

Type Parameters

A

A

Parameters

items

readonly A[]

Returns

Maybe<A>

See

• last for accessing the final element.
• tail for all elements except the first.

Example

Arr.head([1, 2, 3]); // Some(1)
Arr.head([]); // None

indexBy

indexBy: <A, K>(keySelector) => (items) => ReadonlyMap<K, A>

Indexes elements of an array into a ReadonlyMap<K, A> using a key extraction function.

Type Parameters

A

A

K

K

Parameters

keySelector

(item) => K

Returns

(items) => ReadonlyMap<K, A>

See

groupBy for grouping multiple items per key into arrays.

Example

pipe(
  [{ id: 1, name: "Alice" }, { id: 2, name: "Bob" }],
  Arr.indexBy((u) => u.id)
); // ReadonlyMap { 1 => { id: 1, name: "Alice" }, 2 => { id: 2, name: "Bob" } }

init

init: <A>(items) => Maybe<readonly A[]>

Returns all elements except the last, or None if the array is empty.

Type Parameters

A

A

Parameters

items

readonly A[]

Returns

Maybe<readonly A[]>

See

last for accessing the final element.

Example

Arr.init([1, 2, 3]); // Some([1, 2])
Arr.init([]); // None

insertAt

insertAt: <A>(index, item) => (items) => readonly A[]

Returns a new array with item inserted before the element at index. Negative indices are clamped to 0; indices beyond the array length append to the end.

Type Parameters

A

A

Parameters

index

number

item

A

Returns

(items) => readonly A[]

See

removeAt for removing an element at an index.

Example

pipe([1, 2, 3], Arr.insertAt(1, 99)); // [1, 99, 2, 3]
pipe([1, 2, 3], Arr.insertAt(0, 99)); // [99, 1, 2, 3]
pipe([1, 2, 3], Arr.insertAt(3, 99)); // [1, 2, 3, 99]

intersperse

intersperse: <A>(separator) => (items) => readonly A[]

Inserts a separator between every element.

Type Parameters

A

A

Parameters

separator

A

Returns

(items) => readonly A[]

Example

pipe([1, 2, 3], Arr.intersperse(0)); // [1, 0, 2, 0, 3]

is

is: object = ArrIs

is.empty

empty: <A>(items) => boolean

Returns true when the array is empty.

Type Parameters

A

A

Parameters

items

readonly A[]

Returns

boolean

See

nonEmpty for checking if an array contains elements.

is.nonEmpty

nonEmpty: <A>(items) => items is NonEmptyArr<A>

Returns true when the array contains at least one element.

Type Parameters

A

A

Parameters

items

readonly A[]

Returns

items is NonEmptyArr<A>

See

empty for checking if an array is empty.

last

last: <A>(items) => Maybe<A>

Returns the last element of an array, or None if the array is empty.

Type Parameters

A

A

Parameters

items

readonly A[]

Returns

Maybe<A>

See

• head for accessing the first element.
• init for all elements except the last.

Example

Arr.last([1, 2, 3]); // Some(3)
Arr.last([]); // None

map

map: <A, B>(transform) => (items) => readonly B[]

Transforms each element of an array.

Type Parameters

A

A

B

B

Parameters

transform

(item) => B

Returns

(items) => readonly B[]

See

• flatMap for mapping and flattening arrays.
• mapWithIndex for mapping with element indices.

Example

pipe([1, 2, 3], Arr.map(n => n * 2)); // [2, 4, 6]

mapWithIndex

mapWithIndex: <A, B>(transform) => (items) => readonly B[]

Transforms each element using both its value and its zero-based index.

Type Parameters

A

A

B

B

Parameters

transform

(index, item) => B

Returns

(items) => readonly B[]

See

map for mapping without indices.

Example

pipe(
  ["a", "b", "c"],
  Arr.mapWithIndex((i, s) => ({ position: i + 1, value: s }))
); // [{ position: 1, value: "a" }, { position: 2, value: "b" }, { position: 3, value: "c" }]

NonEmpty

NonEmpty: object = ArrNonEmpty

Utilities for working with guaranteed non-empty arrays (NonEmptyArr).

NonEmpty.concat

concat: <A>(other) => (items) => NonEmptyArr<A>

Concatenates a non-empty array with another array, preserving non-emptiness.

Type Parameters

A

A

Parameters

other

readonly A[]

Returns

(items) => NonEmptyArr<A>

Example

pipe([1, 2] as Arr.NonEmpty<number>, Arr.NonEmpty.concat([3, 4])); // [1, 2, 3, 4]

NonEmpty.from

from: object

NonEmpty.from.array

array: <A>(items) => Maybe<NonEmptyArr<A>>

Refines a standard array to a NonEmptyArr, returning Some if length > 0, None otherwise.

Type Parameters

A

A

Parameters

items

readonly A[]

Returns

Maybe<NonEmptyArr<A>>

Example

Arr.NonEmpty.from.array([1, 2]); // Some([1, 2])
Arr.NonEmpty.from.array([]);     // None

NonEmpty.head

head: <A>(items) => A

Returns the first element of a non-empty array without wrapping in Maybe.

Type Parameters

A

A

Parameters

items

NonEmptyArr<A>

Returns

A

See

last for accessing the last element.

Example

Arr.NonEmpty.head([1, 2, 3]); // 1

NonEmpty.intersperse

intersperse: <A>(separator) => (items) => NonEmptyArr<A>

Inserts a separator between every element, preserving non-emptiness.

Type Parameters

A

A

Parameters

separator

A

Returns

(items) => NonEmptyArr<A>

Example

pipe([1, 2, 3] as Arr.NonEmpty<number>, Arr.NonEmpty.intersperse(0)); // [1, 0, 2, 0, 3]

NonEmpty.last

last: <A>(items) => A

Returns the last element of a non-empty array without wrapping in Maybe.

Type Parameters

A

A

Parameters

items

NonEmptyArr<A>

Returns

A

See

head for accessing the first element.

Example

Arr.NonEmpty.last([1, 2, 3]); // 3

NonEmpty.map

map: <A, B>(transform) => (items) => NonEmptyArr<B>

Transforms each element of a non-empty array, preserving non-emptiness.

Type Parameters

A

A

B

B

Parameters

transform

(item) => B

Returns

(items) => NonEmptyArr<B>

Example

pipe([1, 2, 3] as Arr.NonEmpty<number>, Arr.NonEmpty.map(n => n * 2)); // [2, 4, 6]

NonEmpty.mapWithIndex

mapWithIndex: <A, B>(transform) => (items) => NonEmptyArr<B>

Transforms each element with its index, preserving non-emptiness.

Type Parameters

A

A

B

B

Parameters

transform

(index, item) => B

Returns

(items) => NonEmptyArr<B>

Example

pipe(["a", "b"] as Arr.NonEmpty<string>, Arr.NonEmpty.mapWithIndex((i, s) => `${i}:${s}`));
// ["0:a", "1:b"]

NonEmpty.reduce

reduce: <A>(reducer) => (items) => A

Reduces a non-empty array using its first element as the initial accumulator.

Type Parameters

A

A

Parameters

reducer

(accumulator, item) => A

Returns

(items) => A

Example

pipe([1, 2, 3] as Arr.NonEmpty<number>, Arr.NonEmpty.reduce((a, b) => a + b)); // 6

NonEmpty.reverse

reverse: <A>(items) => NonEmptyArr<A>

Reverses a non-empty array, preserving non-emptiness.

Type Parameters

A

A

Parameters

items

NonEmptyArr<A>

Returns

NonEmptyArr<A>

Example

pipe([1, 2, 3] as Arr.NonEmpty<number>, Arr.NonEmpty.reverse); // [3, 2, 1]

NonEmpty.singleton

singleton: <A>(item) => NonEmptyArr<A>

Creates a NonEmptyArr containing a single element.

Type Parameters

A

A

Parameters

item

A

Returns

NonEmptyArr<A>

Example

Arr.NonEmpty.singleton(42); // [42]

NonEmpty.tail

tail: <A>(items) => readonly A[]

Returns all elements except the first.

Type Parameters

A

A

Parameters

items

NonEmptyArr<A>

Returns

readonly A[]

Example

Arr.NonEmpty.tail([1, 2, 3]); // [2, 3]
Arr.NonEmpty.tail([1]);       // []

partition

partition: {<A, B>(predicate): (items) => readonly [readonly B[], readonly Exclude<A, B>[]]; <A>(predicate): (items) => readonly [readonly A[], readonly A[]]; }

Call Signature

<A, B>(predicate): (items) => readonly [readonly B[], readonly Exclude<A, B>[]]

Splits an array into two groups based on a predicate. First group contains elements that satisfy the predicate, second group contains the rest.

Type Parameters

A

A

B

B

Parameters

predicate

(item) => item is B

Returns

(items) => readonly [readonly B[], readonly Exclude<A, B>[]]

See

partitionMap for partitioning with a Result function.

Example

pipe([1, 2, 3, 4], Arr.partition(n => n % 2 === 0)); // [[2, 4], [1, 3]]

Call Signature

<A>(predicate): (items) => readonly [readonly A[], readonly A[]]

Splits an array into two groups based on a predicate. First group contains elements that satisfy the predicate, second group contains the rest.

Type Parameters

A

A

Parameters

predicate

(item) => boolean

Returns

(items) => readonly [readonly A[], readonly A[]]

See

partitionMap for partitioning with a Result function.

Example

pipe([1, 2, 3, 4], Arr.partition(n => n % 2 === 0)); // [[2, 4], [1, 3]]

partitionMap

partitionMap: <A, E, B>(transform) => (items) => readonly [readonly E[], readonly B[]]

Maps each element to a Result, and separates the results into a tuple of failures and successes.

Type Parameters

A

A

E

E

B

B

Parameters

transform

(item) => Result<E, B>

Returns

(items) => readonly [readonly E[], readonly B[]]

See

• partition for partitioning with a boolean predicate.
• partitionMaybe for partitioning with a Maybe function.

Example

pipe(
  [1, 2, 3, 4],
  Arr.partitionMap(n => n % 2 === 0 ? Result.make.ok(n) : Result.make.err(`odd: ${n}`))
); // [["odd: 1", "odd: 3"], [2, 4]]

partitionMaybe

partitionMaybe: <A, B>(transform) => (items) => readonly [readonly A[], readonly B[]]

Partitions an array by applying a function returning Maybe<B>. Elements returning None are gathered into failures (original A values); elements returning Some(b) are gathered into successes (B values).

Type Parameters

A

A

B

B

Parameters

transform

(item) => Maybe<B>

Returns

(items) => readonly [readonly A[], readonly B[]]

See

• partitionMap for partitioning with a Result mapper.
• partition for partitioning with a boolean predicate.

Example

const parseNumber = (s: string) => isNaN(Number(s)) ? Maybe.make.none() : Maybe.make.some(Number(s));
pipe(["1", "abc", "3"], Arr.partitionMaybe(parseNumber)); // [["abc"], [1, 3]]

prepend

prepend: <A>(item) => (items) => NonEmptyArr<A>

Prepends a value to the beginning of an array, returning a NonEmptyArr.

Type Parameters

A

A

Parameters

item

A

Returns

(items) => NonEmptyArr<A>

See

append for adding an element to the end.

Example

pipe([1, 2], Arr.prepend(0)); // [0, 1, 2]

reduce

reduce: <A, B>(initial, reducer) => (items) => B

Reduces an array from the left.

Type Parameters

A

A

B

B

Parameters

initial

B

reducer

(accumulator, item) => B

Returns

(items) => B

See

scan for preserving intermediate accumulation states.

Example

pipe([1, 2, 3], Arr.reduce(0, (acc, n) => acc + n)); // 6

removeAt

removeAt: (index) => <A>(items) => readonly A[]

Returns a new array with the element at index removed. Returns the original array unchanged if index is out of bounds.

Parameters

index

number

Returns

<A>(items) => readonly A[]

See

insertAt for inserting an element at an index.

Example

pipe([1, 2, 3], Arr.removeAt(1)); // [1, 3]
pipe([1, 2, 3], Arr.removeAt(0)); // [2, 3]
pipe([1, 2, 3], Arr.removeAt(5)); // [1, 2, 3]

reverse

reverse: <A>(items) => readonly A[]

Reverses an array. Returns a new array.

Type Parameters

A

A

Parameters

items

readonly A[]

Returns

readonly A[]

Example

Arr.reverse([1, 2, 3]); // [3, 2, 1]

scan

scan: <A, B>(initial, reducer) => (items) => readonly B[]

Like reduce, but returns every intermediate accumulator as an array. The initial value is not included — the output has the same length as the input.

Type Parameters

A

A

B

B

Parameters

initial

B

reducer

(accumulator, item) => B

Returns

(items) => readonly B[]

See

reduce for computing only the final accumulator value.

Example

pipe([1, 2, 3], Arr.scan(0, (acc, n) => acc + n)); // [1, 3, 6]

separate

separate: <E, A>(items) => readonly [readonly E[], readonly A[]]

Separates an array of Result values into two separate lists of errors and successes. Returns a tuple containing [errors, successes].

Type Parameters

E

E

A

A

Parameters

items

readonly Result<E, A>[]

Returns

readonly [readonly E[], readonly A[]]

See

compact for extracting Some values from Maybe instances.

Example

Arr.separate([Result.make.ok(1), Result.make.err("bad"), Result.make.ok(3)]); // [["bad"], [1, 3]]

sequence

sequence: object

Sequences an array of effectful containers into a container of array.

sequence.Maybe

Maybe: <A>(items) => Maybe<readonly A[]> = sequenceMaybe

Type Parameters

A

A

Parameters

items

readonly Maybe<A>[]

Returns

Maybe<readonly A[]>

sequence.Result

Result: <E, A>(items) => Result<E, readonly A[]> = sequenceResult

Type Parameters

E

E

A

A

Parameters

items

readonly Result<E, A>[]

Returns

Result<E, readonly A[]>

sequence.Task

Task: <A>(items) => Task<readonly A[]> = sequenceTask

Type Parameters

A

A

Parameters

items

readonly Task<A>[]

Returns

Task<readonly A[]>

sequence.Validation

Validation: <E, A>(items) => Validation<E, readonly A[]> = sequenceValidation

Type Parameters

E

E

A

A

Parameters

items

readonly Validation<E, A>[]

Returns

Validation<E, readonly A[]>

size

size: <A>(items) => number

Returns the length of an array.

Type Parameters

A

A

Parameters

items

readonly A[]

Returns

number

Example

Arr.size([1, 2, 3]); // 3

some

some: <A>(predicate) => (items) => boolean

Returns true if any element satisfies the predicate.

Type Parameters

A

A

Parameters

predicate

(item) => boolean

Returns

(items) => boolean

See

every for checking whether all elements satisfy a predicate.

Example

pipe([1, 2, 3], Arr.some(n => n > 2)); // true

sortBy

sortBy: <A>(compare) => (items) => readonly A[]

Sorts an array using a comparison function. Returns a new array. To sort with a typed Ordering<A>, prefer Arr.sortWith.

Type Parameters

A

A

Parameters

compare

(first, second) => number

Returns

(items) => readonly A[]

See

sortWith for sorting using typed Ordering instances.

Example

pipe([3, 1, 2], Arr.sortBy((a, b) => a - b)); // [1, 2, 3]

sortWith

sortWith: <A>(ordering) => (items) => readonly A[]

Sorts an array using an Ordering<A>. Returns a new array without mutating the original. Use this over sortBy when you have a typed Ordering<A> from the Ordering module.

Type Parameters

A

A

Parameters

ordering

Ordering<A>

Returns

(items) => readonly A[]

See

sortBy for sorting using a comparator function.

Example

pipe([3, 1, 2], Arr.sortWith(Ordering.number)); // [1, 2, 3]

type Product = { price: number };
const products: Product[] = [{ price: 20 }, { price: 10 }];
const byPrice = pipe(Ordering.number, Ordering.by((p: Product) => p.price));
pipe(products, Arr.sortWith(byPrice));

splitAt

splitAt: (index) => <A>(items) => readonly [readonly A[], readonly A[]]

Splits an array at an index into a [before, after] tuple. Negative indices clamp to 0; indices beyond the array length clamp to the end.

Parameters

index

number

Returns

<A>(items) => readonly [readonly A[], readonly A[]]

Example

pipe([1, 2, 3, 4], Arr.splitAt(2)); // [[1, 2], [3, 4]]
pipe([1, 2, 3], Arr.splitAt(0));    // [[], [1, 2, 3]]
pipe([1, 2, 3], Arr.splitAt(10));   // [[1, 2, 3], []]

tail

tail: <A>(items) => Maybe<readonly A[]>

Returns all elements except the first, or None if the array is empty.

Type Parameters

A

A

Parameters

items

readonly A[]

Returns

Maybe<readonly A[]>

See

head for accessing the first element.

Example

Arr.tail([1, 2, 3]); // Some([2, 3])
Arr.tail([]); // None

take

take: (count) => <A>(items) => readonly A[]

Takes the first n elements from an array.

Parameters

count

number

Returns

<A>(items) => readonly A[]

See

• drop for discarding the first n elements.
• takeWhile for taking elements based on a predicate.

Example

pipe([1, 2, 3, 4], Arr.take(2)); // [1, 2]

takeWhile

takeWhile: <A>(predicate) => (items) => readonly A[]

Takes elements from the start while the predicate holds.

Type Parameters

A

A

Parameters

predicate

(item) => boolean

Returns

(items) => readonly A[]

See

• dropWhile for discarding elements while a predicate holds.
• take for taking a fixed count of elements.

Example

pipe([1, 2, 3, 1], Arr.takeWhile(n => n < 3)); // [1, 2]

traverse

traverse: object

Maps elements to an effectful container and aggregates the results.

traverse.Maybe

Maybe: <A, B>(transform) => (items) => Maybe<readonly B[]> = traverseMaybe

Type Parameters

A

A

B

B

Parameters

transform

(item) => Maybe<B>

Returns

(items) => Maybe<readonly B[]>

traverse.Result

Result: <E, A, B>(transform) => (items) => Result<E, readonly B[]> = traverseResult

Type Parameters

E

E

A

A

B

B

Parameters

transform

(item) => Result<E, B>

Returns

(items) => Result<E, readonly B[]>

traverse.Task

Task: <A, B>(transform, options?) => (items) => Task<readonly B[]> = traverseTask

Type Parameters

A

A

B

B

Parameters

transform

(item) => Task<B>

options?

concurrency?

number

Returns

(items) => Task<readonly B[]>

traverse.Validation

Validation: <E, A, B>(transform) => (items) => Validation<E, readonly B[]> = traverseValidation

Type Parameters

E

E

A

A

B

B

Parameters

transform

(item) => Validation<E, B>

Returns

(items) => Validation<E, readonly B[]>

unfold

unfold: <A, S>(initial, step) => readonly A[]

Generates an array from an initial seed state until step returns None.

Type Parameters

A

A

S

S

Parameters

initial

S

step

(state) => Maybe<readonly [A, S]>

Returns

readonly A[]

Example

Arr.unfold(1, (n) => n > 3 ? Maybe.make.none() : Maybe.make.some([n, n + 1]));
// [1, 2, 3]

uniq

uniq: <A>(items) => readonly A[]

Removes duplicate elements using strict equality.

Type Parameters

A

A

Parameters

items

readonly A[]

Returns

readonly A[]

See

• uniqBy for deduplicating by a key projection.
• uniqWith for deduplicating with custom equality.

Example

Arr.uniq([1, 2, 2, 3, 1]); // [1, 2, 3]

uniqBy

uniqBy: <A, B>(keySelector) => (items) => readonly A[]

Removes duplicate elements by comparing the result of a key function.

Type Parameters

A

A

B

B

Parameters

keySelector

(item) => B

Returns

(items) => readonly A[]

See

• uniq for reference-equality deduplication.
• uniqWith for deduplicating with custom equality.

Example

pipe(
  [{id: 1, name: "a"}, {id: 1, name: "b"}, {id: 2, name: "c"}],
  Arr.uniqBy(x => x.id)
); // [{id: 1, name: "a"}, {id: 2, name: "c"}]

uniqWith

uniqWith: <A>(areEqual) => (items) => readonly A[]

Removes duplicate elements using a custom equality check. Preserves the order of first occurrences. Complements uniq (reference equality) and uniqBy (key extraction).

Type Parameters

A

A

Parameters

areEqual

Equality<A>

Returns

(items) => readonly A[]

See

• uniq for reference-equality deduplication.
• uniqBy for key-based deduplication.

Example

type Point = { x: number; y: number };
const eqPoint: Equality<Point> = (a, b) => a.x === b.x && a.y === b.y;

pipe(
  [{ x: 1, y: 1 }, { x: 2, y: 2 }, { x: 1, y: 1 }],
  Arr.uniqWith(eqPoint),
); // [{ x: 1, y: 1 }, { x: 2, y: 2 }]

windowed

windowed: (windowSize, options?) => <A>(items) => readonly (readonly A[])[]

Produces a sliding window of size elements over an array, advancing by step (default 1). Returns an empty array if size <= 0 or size > items.length.

Parameters

windowSize

number

options?

step?

number

Returns

<A>(items) => readonly (readonly A[])[]

Example

pipe([1, 2, 3, 4], Arr.windowed(2)); // [[1, 2], [2, 3], [3, 4]]
pipe([1, 2, 3, 4], Arr.windowed(2, { step: 2 })); // [[1, 2], [3, 4]]

zip

zip: <B>(other) => <A>(items) => readonly (readonly [A, B])[]

Pairs up elements from two arrays. Stops at the shorter array.

Type Parameters

B

B

Parameters

other

readonly B[]

Returns

<A>(items) => readonly (readonly [A, B])[]

See

zipWith for pairing elements with a custom combining function.

Example

pipe([1, 2, 3], Arr.zip(["a", "b"])); // [[1, "a"], [2, "b"]]

zipWith

zipWith: <A, B, C>(combine) => (other) => (items) => readonly C[]

Combines elements from two arrays using a function. Stops at the shorter array.

Type Parameters

A

A

B

B

C

C

Parameters

combine

(first, second) => C

Returns

(other) => (items) => readonly C[]

See

zip for pairing elements into 2-tuples.

Example

pipe([1, 2], Arr.zipWith((a: number, b: string) => `${a}${b}`)(["a", "b"])); // ["1a", "2b"]