Arr

const Arr: object

Defined in: Data/Arr.ts:1160

Type Declaration

append

append: <A>(value) => (data) => NonEmptyArr<A>

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

Type Parameters

A

A

Parameters

value

A

Returns

(data) => NonEmptyArr<A>

Example

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

at

at: (index) => <A>(data) => 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>(data) => 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>(keyFn) => (data) => readonly readonly A[][]

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

Type Parameters

A

A

K

K

Parameters

keyFn

(a) => K

Returns

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

Example

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

chunksOf

chunksOf: (n) => <A>(data) => readonly readonly A[][]

Splits an array into chunks of the given size.

Parameters

n

number

Returns

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

Example

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

compact

compact: <A>(data) => 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

data

readonly Maybe<A>[]

Returns

readonly A[]

Example

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

concat

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

Concatenates a standard array with another array.

Type Parameters

A

A

Parameters

other

readonly A[]

Returns

(data) => readonly A[]

Example

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

dedupeAdjacent

dedupeAdjacent: <A>(eq) => (data) => readonly A[]

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

Type Parameters

A

A

Parameters

eq?

Equality<A> = ...

Returns

(data) => readonly A[]

Example

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

drop

drop: (n) => <A>(data) => readonly A[]

Drops the first n elements from an array.

Parameters

n

number

Returns

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

Example

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

dropWhile

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

Drops elements from the start while the predicate holds.

Type Parameters

A

A

Parameters

predicate

(a) => boolean

Returns

(data) => readonly A[]

Example

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

every

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

Returns true if all elements satisfy the predicate.

Type Parameters

A

A

Parameters

predicate

(a) => boolean

Returns

(data) => boolean

Example

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

filter

filter: <A>(predicate) => (data) => readonly A[]

Filters elements that satisfy the predicate.

Type Parameters

A

A

Parameters

predicate

(a) => boolean

Returns

(data) => readonly A[]

Example

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

filterMap

filterMap: <A, B>(f) => (data) => 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

f

(a) => Maybe<B>

Returns

(data) => readonly B[]

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>(predicate) => (data) => Maybe<A>

Returns the first element matching the predicate, or None.

Type Parameters

A

A

Parameters

predicate

(a) => boolean

Returns

(data) => Maybe<A>

Example

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

findIndex

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

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

Type Parameters

A

A

Parameters

predicate

(a) => boolean

Returns

(data) => Maybe<number>

Example

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

findLast

findLast: <A>(predicate) => (data) => Maybe<A>

Returns the last element matching the predicate, or None.

Type Parameters

A

A

Parameters

predicate

(a) => boolean

Returns

(data) => Maybe<A>

Example

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

findMap

findMap: <A, B>(f) => (data) => Maybe<B>

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

Type Parameters

A

A

B

B

Parameters

f

(a) => Maybe<B>

Returns

(data) => Maybe<B>

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>(f) => (data) => readonly B[]

Maps each element to an array and flattens the result.

Type Parameters

A

A

B

B

Parameters

f

(a) => readonly B[]

Returns

(data) => readonly B[]

Example

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

flatten

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

Flattens a nested array by one level.

Type Parameters

A

A

Parameters

data

readonly readonly A[][]

Returns

readonly A[]

Example

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

frequencies

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

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

Type Parameters

A

A

Parameters

data

readonly A[]

Returns

ReadonlyMap<A, number>

Example

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

from

from: object = ArrFrom

from.Array

Array: <A>(data) => Maybe<NonEmptyArr<A>>

Type Parameters

A

A

Parameters

data

readonly A[]

Returns

Maybe<NonEmptyArr<A>>

groupBy

groupBy: <A>(f) => (data) => Record<string, NonEmptyArr<A>>

Groups elements by a key function.

Type Parameters

A

A

Parameters

f

(a) => string

Returns

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

Example

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

head

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

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

Type Parameters

A

A

Parameters

data

readonly A[]

Returns

Maybe<A>

Example

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

indexBy

indexBy: <A, K>(keyFn) => (data) => 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

keyFn

(a) => K

Returns

(data) => ReadonlyMap<K, A>

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>(data) => Maybe<readonly A[]>

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

Type Parameters

A

A

Parameters

data

readonly A[]

Returns

Maybe<readonly A[]>

Example

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

insertAt

insertAt: <A>(index, item) => (data) => 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

(data) => readonly A[]

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>(sep) => (data) => readonly A[]

Inserts a separator between every element.

Type Parameters

A

A

Parameters

sep

A

Returns

(data) => readonly A[]

Example

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

is

is: object = ArrIs

is.empty

empty: <A>(data) => data is readonly []

Type Parameters

A

A

Parameters

data

readonly A[]

Returns

data is readonly []

is.nonEmpty

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

Type Parameters

A

A

Parameters

data

readonly A[]

Returns

data is NonEmptyArr<A>

last

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

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

Type Parameters

A

A

Parameters

data

readonly A[]

Returns

Maybe<A>

Example

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

map

map: <A, B>(f) => (data) => readonly B[]

Transforms each element of an array.

Type Parameters

A

A

B

B

Parameters

f

(a) => B

Returns

(data) => readonly B[]

Example

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

mapWithIndex

mapWithIndex: <A, B>(f) => (data) => readonly B[]

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

Type Parameters

A

A

B

B

Parameters

f

(i, a) => B

Returns

(data) => readonly B[]

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

NonEmpty.concat

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

Type Parameters

A

A

Parameters

other

readonly A[]

Returns

(data) => NonEmptyArr<A>

NonEmpty.from

from: object

NonEmpty.from.Array

Array: <A>(data) => Maybe<NonEmptyArr<A>>

Type Parameters

A

A

Parameters

data

readonly A[]

Returns

Maybe<NonEmptyArr<A>>

NonEmpty.head

head: <A>(data) => A

Type Parameters

A

A

Parameters

data

NonEmptyArr<A>

Returns

A

NonEmpty.intersperse

intersperse: <A>(sep) => (data) => NonEmptyArr<A>

Type Parameters

A

A

Parameters

sep

A

Returns

(data) => NonEmptyArr<A>

NonEmpty.last

last: <A>(data) => A

Type Parameters

A

A

Parameters

data

NonEmptyArr<A>

Returns

A

NonEmpty.map

map: <A, B>(f) => (data) => NonEmptyArr<B>

Type Parameters

A

A

B

B

Parameters

f

(a) => B

Returns

(data) => NonEmptyArr<B>

NonEmpty.mapWithIndex

mapWithIndex: <A, B>(f) => (data) => NonEmptyArr<B>

Type Parameters

A

A

B

B

Parameters

f

(i, a) => B

Returns

(data) => NonEmptyArr<B>

NonEmpty.reduce

reduce: <A>(f) => (data) => A

Type Parameters

A

A

Parameters

f

(acc, a) => A

Returns

(data) => A

NonEmpty.reverse

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

Type Parameters

A

A

Parameters

data

NonEmptyArr<A>

Returns

NonEmptyArr<A>

NonEmpty.singleton

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

Type Parameters

A

A

Parameters

value

A

Returns

NonEmptyArr<A>

NonEmpty.tail

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

Type Parameters

A

A

Parameters

data

NonEmptyArr<A>

Returns

readonly A[]

partition

partition: <A>(predicate) => (data) => 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

(a) => boolean

Returns

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

Example

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

partitionMap

partitionMap: <A, E, B>(f) => (data) => 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

f

(a) => Result<E, B>

Returns

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

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>(f) => (data) => 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

f

(a) => Maybe<B>

Returns

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

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>(value) => (data) => NonEmptyArr<A>

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

Type Parameters

A

A

Parameters

value

A

Returns

(data) => NonEmptyArr<A>

Example

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

reduce

reduce: <A, B>(initial, f) => (data) => B

Reduces an array from the left.

Type Parameters

A

A

B

B

Parameters

initial

B

f

(acc, a) => B

Returns

(data) => B

Example

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

removeAt

removeAt: (index) => <A>(data) => 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>(data) => readonly A[]

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>(data) => readonly A[]

Reverses an array. Returns a new array.

Type Parameters

A

A

Parameters

data

readonly A[]

Returns

readonly A[]

Example

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

scan

scan: <A, B>(initial, f) => (data) => 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

f

(acc, a) => B

Returns

(data) => readonly B[]

Example

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

separate

separate: <E, A>(data) => 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

data

readonly Result<E, A>[]

Returns

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

Example

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

sequence

sequence: object

sequence.Maybe

Maybe: <A>(data) => Maybe<readonly A[]> = ArrMaybe.sequence

Collects an array of Maybe instances into a Maybe of array. Returns None if any element is None.

Type Parameters

A

A

Parameters

data

readonly Maybe<A>[]

Returns

Maybe<readonly A[]>

Example

Arr.sequence.Maybe([Maybe.make.some(1), Maybe.make.some(2)]); // Some([1, 2])
Arr.sequence.Maybe([Maybe.make.some(1), Maybe.make.none()]); // None

sequence.Result

Result: <E, A>(data) => Result<E, readonly A[]> = ArrResult.sequence

Collects an array of Results into a Result of array. Returns the first Err if any element is Err.

Type Parameters

E

E

A

A

Parameters

data

readonly Result<E, A>[]

Returns

Result<E, readonly A[]>

Example

Arr.sequence.Result([Result.make.ok(1), Result.make.ok(2)]); // Ok([1, 2])
Arr.sequence.Result([Result.make.ok(1), Result.make.err("bad")]); // Err("bad")

sequence.Task

Task: TaskSequence = _sequenceTask

size

size: <A>(data) => number

Returns the length of an array.

Type Parameters

A

A

Parameters

data

readonly A[]

Returns

number

Example

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

some

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

Returns true if any element satisfies the predicate.

Type Parameters

A

A

Parameters

predicate

(a) => boolean

Returns

(data) => boolean

Example

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

sortBy

sortBy: <A>(compare) => (data) => 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

(a, b) => number

Returns

(data) => readonly A[]

Example

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

sortWith

sortWith: <A>(ord) => (data) => 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

ord

Ordering<A>

Returns

(data) => readonly A[]

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>(data) => 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>(data) => 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>(data) => Maybe<readonly A[]>

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

Type Parameters

A

A

Parameters

data

readonly A[]

Returns

Maybe<readonly A[]>

Example

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

take

take: (n) => <A>(data) => readonly A[]

Takes the first n elements from an array.

Parameters

n

number

Returns

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

Example

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

takeWhile

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

Takes elements from the start while the predicate holds.

Type Parameters

A

A

Parameters

predicate

(a) => boolean

Returns

(data) => readonly A[]

Example

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

traverse

traverse: object

traverse.Maybe

Maybe: <A, B>(f) => (data) => Maybe<readonly B[]> = ArrMaybe.traverse

Maps each element to a Maybe and collects the results. Returns None if any mapping returns None.

Type Parameters

A

A

B

B

Parameters

f

(a) => Maybe<B>

Returns

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

Example

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

pipe(["1", "2", "3"], Arr.traverse.Maybe(parseNum)); // Some([1, 2, 3])
pipe(["1", "x", "3"], Arr.traverse.Maybe(parseNum)); // None

traverse.Result

Result: <E, A, B>(f) => (data) => Result<E, readonly B[]> = ArrResult.traverse

Maps each element to a Result and collects the results. Returns the first Err if any mapping fails.

Type Parameters

E

E

A

A

B

B

Parameters

f

(a) => Result<E, B>

Returns

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

Example

pipe(
  [1, 2, 3],
  Arr.traverse.Result((n: number) => n > 0 ? Result.make.ok(n) : Result.make.err("negative"))
); // Ok([1, 2, 3])

traverse.Task

Task: TaskTraverse = _traverseTask

unfold

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

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

Type Parameters

A

A

S

S

Parameters

initial

S

f

(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>(data) => readonly A[]

Removes duplicate elements using strict equality.

Type Parameters

A

A

Parameters

data

readonly A[]

Returns

readonly A[]

Example

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

uniqBy

uniqBy: <A, B>(f) => (data) => readonly A[]

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

Type Parameters

A

A

B

B

Parameters

f

(a) => B

Returns

(data) => readonly A[]

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>(eq) => (data) => 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

eq

Equality<A>

Returns

(data) => readonly A[]

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>(data) => 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 > data.length.

Parameters

windowSize

number

options?

step?

number

Returns

<A>(data) => 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>(data) => 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>(data) => readonly readonly [A, B][]

Example

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

zipWith

zipWith: <A, B, C>(f) => (other) => (data) => readonly C[]

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

Type Parameters

A

A

B

B

C

C

Parameters

f

(a, b) => C

Returns

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

Example

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