API / Js / Array

Array

Provides bindings to JavaScript’s Array functions. These bindings are optimized for pipe-last (|>), where the array to be processed is the last parameter in the function.

Here is an example to find the sum of squares of all even numbers in an array. Without pipe last, we must call the functions in reverse order:

Examples

RESCRIPT
let isEven = x => mod(x, 2) == 0
let square = x => x * x
let result = {
  open Js.Array
  reduce(\"+", 0, map(square, filter(isEven, [5, 2, 3, 4, 1])))
}

With pipe last, we call the functions in the “natural” order:

RESCRIPT
let isEven = x => mod(x, 2) == 0
let square = x => x * x
let result = {
  open Js.Array
  [5, 2, 3, 4, 1] |> filter(isEven) |> map(square) |> reduce("+", 0)
}

t

RESCRIPT
type t<'a> = array<'a>

The type used to describe a JavaScript array.

array_like

RESCRIPT
type array_like<'a> = Js_array2.array_like<'a>

A type used to describe JavaScript objects that are like an array or are iterable.

from

RESCRIPT
let from: array_like<'a> => array<'a>

Creates a shallow copy of an array from an array-like object. See Array.from on MDN.

Examples

RESCRIPT
let strArr = Js.String.castToArrayLike("abcd")
Js.Array.from(strArr) == ["a", "b", "c", "d"]

fromMap

RESCRIPT
let fromMap: (array_like<'a>, 'a => 'b) => array<'b>

Creates a new array by applying a function (the second argument) to each item in the array_like first argument. See Array.from on MDN.

Examples

RESCRIPT
let strArr = Js.String.castToArrayLike("abcd")
let code = s => Js.String.charCodeAt(0, s)
Js.Array.fromMap(strArr, code) == [97.0, 98.0, 99.0, 100.0]

isArray

RESCRIPT
let isArray: 'a => bool

length

RESCRIPT
let length: array<'a> => int

Returns the number of elements in the array. See Array.length on MDN.

copyWithin

RESCRIPT
let copyWithin: (t<'a>, ~to_: int) => 'this

Copies from the first element in the given array to the designated ~to_ position, returning the resulting array. This function modifies the original array. See Array.copyWithin on MDN.

Examples

RESCRIPT
let arr = [100, 101, 102, 103, 104]
Js.Array.copyWithin(~to_=2, arr) == [100, 101, 100, 101, 102]
arr == [100, 101, 100, 101, 102]

copyWithin

RESCRIPT
let copyWithin: (~to_: int, t<'a>) => 'b

copyWithinFrom

RESCRIPT
let copyWithinFrom: (t<'a>, ~to_: int, ~from: int) => 'this

Copies starting at element ~from in the given array to the designated ~to_ position, returning the resulting array. This function modifies the original array. See Array.copyWithin on MDN.

Examples

RESCRIPT
let arr = [100, 101, 102, 103, 104]
Js.Array.copyWithinFrom(~from=2, ~to_=0, arr) == [102, 103, 104, 103, 104]
arr == [102, 103, 104, 103, 104]

copyWithinFrom

RESCRIPT
let copyWithinFrom: (~to_: int, ~from: int, t<'a>) => 'b

copyWithinFromRange

RESCRIPT
let copyWithinFromRange: (t<'a>, ~to_: int, ~start: int, ~end_: int) => 'this

Copies starting at element ~start in the given array up to but not including ~end_ to the designated ~to_ position, returning the resulting array. This function modifies the original array. See Array.copyWithin on MDN.

Examples

RESCRIPT
let arr = [100, 101, 102, 103, 104, 105]
Js.Array.copyWithinFromRange(~start=2, ~end_=5, ~to_=1, arr) == [100, 102, 103, 104, 104, 105]
arr == [100, 102, 103, 104, 104, 105]

copyWithinFromRange

RESCRIPT
let copyWithinFromRange: (~to_: int, ~start: int, ~end_: int, t<'a>) => 'b

fillInPlace

RESCRIPT
let fillInPlace: (t<'a>, 'a) => 'this

Sets all elements of the given array (the second arumgent) to the designated value (the first argument), returning the resulting array. This function modifies the original array. See Array.fill on MDN.

Examples

RESCRIPT
let arr = [100, 101, 102, 103, 104]
Js.Array.fillInPlace(99, arr) == [99, 99, 99, 99, 99]
arr == [99, 99, 99, 99, 99]

fillInPlace

RESCRIPT
let fillInPlace: ('a, t<'a>) => 'b

fillFromInPlace

RESCRIPT
let fillFromInPlace: (t<'a>, 'a, ~from: int) => 'this

Sets all elements of the given array (the last arumgent) from position ~from to the end to the designated value (the first argument), returning the resulting array. This function modifies the original array. See Array.fill on MDN.

Examples

RESCRIPT
let arr = [100, 101, 102, 103, 104]
Js.Array.fillFromInPlace(99, ~from=2, arr) == [100, 101, 99, 99, 99]
arr == [100, 101, 99, 99, 99]

fillFromInPlace

RESCRIPT
let fillFromInPlace: ('a, ~from: int, t<'a>) => 'b

fillRangeInPlace

RESCRIPT
let fillRangeInPlace: (t<'a>, 'a, ~start: int, ~end_: int) => 'this

Sets the elements of the given array (the last arumgent) from position ~start up to but not including position ~end_ to the designated value (the first argument), returning the resulting array. This function modifies the original array. See Array.fill on MDN.

Examples

RESCRIPT
let arr = [100, 101, 102, 103, 104]
Js.Array.fillRangeInPlace(99, ~start=1, ~end_=4, arr) == [100, 99, 99, 99, 104]
arr == [100, 99, 99, 99, 104]

fillRangeInPlace

RESCRIPT
let fillRangeInPlace: ('a, ~start: int, ~end_: int, t<'a>) => 'b

pop

RESCRIPT
let pop: t<'a> => option<'a>

If the array is not empty, removes the last element and returns it as Some(value); returns None if the array is empty. This function modifies the original array. See Array.pop on MDN.

Examples

RESCRIPT
let arr = [100, 101, 102, 103, 104]
Js.Array.pop(arr) == Some(104)
arr == [100, 101, 102, 103]

let empty: array<int> = []
Js.Array.pop(empty) == None

push

RESCRIPT
let push: (t<'a>, 'a) => int

Appends the given value to the array, returning the number of elements in the updated array. This function modifies the original array. See Array.push on MDN.

Examples

RESCRIPT
let arr = ["ant", "bee", "cat"]
Js.Array.push("dog", arr) == 4
arr == ["ant", "bee", "cat", "dog"]

push

RESCRIPT
let push: ('a, t<'a>) => int

pushMany

RESCRIPT
let pushMany: (t<'a>, array<'a>) => int

Appends the values from one array (the first argument) to another (the second argument), returning the number of elements in the updated array. This function modifies the original array. See Array.push on MDN.

Examples

RESCRIPT
let arr = ["ant", "bee", "cat"]
Js.Array.pushMany(["dog", "elk"], arr) == 5
arr == ["ant", "bee", "cat", "dog", "elk"]

pushMany

RESCRIPT
let pushMany: (array<'a>, t<'a>) => int

reverseInPlace

RESCRIPT
let reverseInPlace: t<'a> => 'this

Returns an array with the elements of the input array in reverse order. This function modifies the original array. See Array.reverse on MDN.

Examples

RESCRIPT
let arr = ["ant", "bee", "cat"]
Js.Array.reverseInPlace(arr) == ["cat", "bee", "ant"]
arr == ["cat", "bee", "ant"]

shift

RESCRIPT
let shift: t<'a> => option<'a>

If the array is not empty, removes the first element and returns it as Some(value); returns None if the array is empty. This function modifies the original array. See Array.shift on MDN.

Examples

RESCRIPT
let arr = [100, 101, 102, 103, 104]
Js.Array.shift(arr) == Some(100)
arr == [101, 102, 103, 104]

let empty: array<int> = []
Js.Array.shift(empty) == None

sortInPlace

RESCRIPT
let sortInPlace: t<'a> => 'this

Sorts the given array in place and returns the sorted array. JavaScript sorts the array by converting the arguments to UTF-16 strings and sorting them. See the second example with sorting numbers, which does not do a numeric sort. This function modifies the original array. See Array.sort on MDN.

Examples

RESCRIPT
let words = ["bee", "dog", "ant", "cat"]
Js.Array.sortInPlace(words) == ["ant", "bee", "cat", "dog"]
words == ["ant", "bee", "cat", "dog"]

let numbers = [3, 30, 10, 1, 20, 2]
Js.Array.sortInPlace(numbers) == [1, 10, 2, 20, 3, 30]
numbers == [1, 10, 2, 20, 3, 30]

sortInPlaceWith

RESCRIPT
let sortInPlaceWith: (t<'a>, ('a, 'a) => int) => 'this

Sorts the given array in place and returns the sorted array. This function modifies the original array.

The first argument to sortInPlaceWith() is a function that compares two items from the array and returns:

  • an integer less than zero if the first item is less than the second item

  • zero if the items are equal

  • an integer greater than zero if the first item is greater than the second item

See Array.sort on MDN.

Examples

RESCRIPT
// sort by word length
let words = ["horse", "aardvark", "dog", "camel"]
let byLength = (s1, s2) => Js.String.length(s1) - Js.String.length(s2)

Js.Array.sortInPlaceWith(byLength, words) == ["dog", "horse", "camel", "aardvark"]

// sort in reverse numeric order
let numbers = [3, 30, 10, 1, 20, 2]
let reverseNumeric = (n1, n2) => n2 - n1
Js.Array.sortInPlaceWith(reverseNumeric, numbers) == [30, 20, 10, 3, 2, 1]

sortInPlaceWith

RESCRIPT
let sortInPlaceWith: (('a, 'a) => int, t<'a>) => 'b

spliceInPlace

RESCRIPT
let spliceInPlace: (t<'a>, ~pos: int, ~remove: int, ~add: array<'a>) => 'this

Starting at position ~pos, remove ~remove elements and then add the elements from the ~add array. Returns an array consisting of the removed items. This function modifies the original array. See Array.splice on MDN.

Examples

RESCRIPT
let arr = ["a", "b", "c", "d", "e", "f"]
Js.Array.spliceInPlace(~pos=2, ~remove=2, ~add=["x", "y", "z"], arr) == ["c", "d"]
arr == ["a", "b", "x", "y", "z", "e", "f"]

let arr2 = ["a", "b", "c", "d"]
Js.Array.spliceInPlace(~pos=3, ~remove=0, ~add=["x", "y"], arr2) == []
arr2 == ["a", "b", "c", "x", "y", "d"]

let arr3 = ["a", "b", "c", "d", "e", "f"]
Js.Array.spliceInPlace(~pos=9, ~remove=2, ~add=["x", "y", "z"], arr3) == []
arr3 == ["a", "b", "c", "d", "e", "f", "x", "y", "z"]

spliceInPlace

RESCRIPT
let spliceInPlace: (~pos: int, ~remove: int, ~add: array<'a>, t<'a>) => 'b

removeFromInPlace

RESCRIPT
let removeFromInPlace: (t<'a>, ~pos: int) => 'this

Removes elements from the given array starting at position ~pos to the end of the array, returning the removed elements. This function modifies the original array. See Array.splice on MDN.

Examples

RESCRIPT
let arr = ["a", "b", "c", "d", "e", "f"]
Js.Array.removeFromInPlace(~pos=4, arr) == ["e", "f"]
arr == ["a", "b", "c", "d"]

removeFromInPlace

RESCRIPT
let removeFromInPlace: (~pos: int, t<'a>) => 'b

removeCountInPlace

RESCRIPT
let removeCountInPlace: (t<'a>, ~pos: int, ~count: int) => 'this

Removes ~count elements from the given array starting at position ~pos, returning the removed elements. This function modifies the original array. See Array.splice on MDN.

Examples

RESCRIPT
let arr = ["a", "b", "c", "d", "e", "f"]
Js.Array.removeCountInPlace(~pos=2, ~count=3, arr) == ["c", "d", "e"]
arr == ["a", "b", "f"]

removeCountInPlace

RESCRIPT
let removeCountInPlace: (~pos: int, ~count: int, t<'a>) => 'b

unshift

RESCRIPT
let unshift: (t<'a>, 'a) => int

Adds the given element to the array, returning the new number of elements in the array. This function modifies the original array. See Array.unshift on MDN.

Examples

RESCRIPT
let arr = ["b", "c", "d"]
Js.Array.unshift("a", arr) == 4
arr == ["a", "b", "c", "d"]

unshift

RESCRIPT
let unshift: ('a, t<'a>) => int

unshiftMany

RESCRIPT
let unshiftMany: (t<'a>, array<'a>) => int

Adds the elements in the first array argument at the beginning of the second array argument, returning the new number of elements in the array. This function modifies the original array. See Array.unshift on MDN.

Examples

RESCRIPT
let arr = ["d", "e"]
Js.Array.unshiftMany(["a", "b", "c"], arr) == 5
arr == ["a", "b", "c", "d", "e"]

unshiftMany

RESCRIPT
let unshiftMany: (array<'a>, t<'a>) => int

concat

RESCRIPT
let concat: (t<'a>, 'this) => 'this

Concatenates the first array argument to the second array argument, returning a new array. The original arrays are not modified. See Array.concat on MDN.

Examples

RESCRIPT
Js.Array.concat(["c", "d", "e"], ["a", "b"]) == ["a", "b", "c", "d", "e"]

concat

RESCRIPT
let concat: ('a, t<'b>) => 'a

concatMany

RESCRIPT
let concatMany: (t<'a>, array<'this>) => 'this

The first argument to concatMany() is an array of arrays; these are added at the end of the second argument, returning a new array. See Array.concat on MDN.

Examples

RESCRIPT
Js.Array.concatMany([["d", "e"], ["f", "g", "h"]], ["a", "b", "c"]) == [
    "a",
    "b",
    "c",
    "d",
    "e",
    "f",
    "g",
    "h",
  ]

concatMany

RESCRIPT
let concatMany: (array<'a>, t<'b>) => 'a

includes

RESCRIPT
let includes: (t<'a>, 'a) => bool

Returns true if the given value is in the array, false otherwise. See Array.includes on MDN.

Examples

RESCRIPT
Js.Array.includes("b", ["a", "b", "c"]) == true
Js.Array.includes("x", ["a", "b", "c"]) == false

includes

RESCRIPT
let includes: ('a, t<'a>) => bool

indexOf

RESCRIPT
let indexOf: (t<'a>, 'a) => int

Returns the index of the first element in the array that has the given value. If the value is not in the array, returns -1. See Array.indexOf on MDN.

Examples

RESCRIPT
Js.Array.indexOf(102, [100, 101, 102, 103]) == 2
Js.Array.indexOf(999, [100, 101, 102, 103]) == -1

indexOf

RESCRIPT
let indexOf: ('a, t<'a>) => int

indexOfFrom

RESCRIPT
let indexOfFrom: (t<'a>, 'a, ~from: int) => int

Returns the index of the first element in the array with the given value. The search starts at position ~from. See Array.indexOf on MDN.

Examples

RESCRIPT
Js.Array.indexOfFrom("a", ~from=2, ["a", "b", "a", "c", "a"]) == 2
Js.Array.indexOfFrom("a", ~from=3, ["a", "b", "a", "c", "a"]) == 4
Js.Array.indexOfFrom("b", ~from=2, ["a", "b", "a", "c", "a"]) == -1

indexOfFrom

RESCRIPT
let indexOfFrom: ('a, ~from: int, t<'a>) => int

join

Deprecated

please use joinWith instead

RESCRIPT
let join: t<'a> => string

joinWith

RESCRIPT
let joinWith: (t<'a>, string) => string

This function converts each element of the array to a string (via JavaScript) and concatenates them, separated by the string given in the first argument, into a single string. See Array.join on MDN.

Examples

RESCRIPT
Js.Array.joinWith("--", ["ant", "bee", "cat"]) == "ant--bee--cat"
Js.Array.joinWith("", ["door", "bell"]) == "doorbell"
Js.Array.joinWith("/", [2020, 9, 4]) == "2020/9/4"
Js.Array.joinWith(";", [2.5, 3.6, 3e-2]) == "2.5;3.6;0.03"

joinWith

RESCRIPT
let joinWith: (string, t<'a>) => string

lastIndexOf

RESCRIPT
let lastIndexOf: (t<'a>, 'a) => int

Returns the index of the last element in the array that has the given value. If the value is not in the array, returns -1. See Array.lastIndexOf on MDN.

Examples

RESCRIPT
Js.Array.lastIndexOf("a", ["a", "b", "a", "c"]) == 2
Js.Array.lastIndexOf("x", ["a", "b", "a", "c"]) == -1

lastIndexOf

RESCRIPT
let lastIndexOf: ('a, t<'a>) => int

lastIndexOfFrom

RESCRIPT
let lastIndexOfFrom: (t<'a>, 'a, ~from: int) => int

Returns the index of the last element in the array that has the given value, searching from position ~from down to the start of the array. If the value is not in the array, returns -1. See Array.lastIndexOf on MDN.

Examples

RESCRIPT
Js.Array.lastIndexOfFrom("a", ~from=3, ["a", "b", "a", "c", "a", "d"]) == 2
Js.Array.lastIndexOfFrom("c", ~from=2, ["a", "b", "a", "c", "a", "d"]) == -1

lastIndexOfFrom

RESCRIPT
let lastIndexOfFrom: ('a, ~from: int, t<'a>) => int

slice

RESCRIPT
let slice: (t<'a>, ~start: int, ~end_: int) => 'this

Returns a shallow copy of the given array from the ~start index up to but not including the ~end_ position. Negative numbers indicate an offset from the end of the array. See Array.slice on MDN.

Examples

RESCRIPT
let arr = [100, 101, 102, 103, 104, 105, 106]
Js.Array.slice(~start=2, ~end_=5, arr) == [102, 103, 104]
Js.Array.slice(~start=-3, ~end_=-1, arr) == [104, 105]
Js.Array.slice(~start=9, ~end_=10, arr) == []

slice

RESCRIPT
let slice: (int, ~end_: int, ~obj: t<'a>) => 'b

copy

RESCRIPT
let copy: t<'a> => 'this

Returns a copy of the entire array. Same as Js.Array.Slice(~start=0, ~end_=Js.Array.length(arr), arr). See Array.slice on MDN.

sliceFrom

RESCRIPT
let sliceFrom: (t<'a>, int) => 'this

Returns a shallow copy of the given array from the given index to the end. See Array.slice on MDN.

Examples

RESCRIPT
Js.Array.sliceFrom(2, [100, 101, 102, 103, 104]) == [102, 103, 104]

sliceFrom

RESCRIPT
let sliceFrom: (int, t<'a>) => 'b

toString

RESCRIPT
let toString: t<'a> => string

Converts the array to a string. Each element is converted to a string using JavaScript. Unlike the JavaScript Array.toString(), all elements in a ReasonML array must have the same type. See Array.toString on MDN.

Examples

RESCRIPT
Js.Array.toString([3.5, 4.6, 7.8]) == "3.5,4.6,7.8"
Js.Array.toString(["a", "b", "c"]) == "a,b,c"

toLocaleString

RESCRIPT
let toLocaleString: t<'a> => string

Converts the array to a string using the conventions of the current locale. Each element is converted to a string using JavaScript. Unlike the JavaScript Array.toLocaleString(), all elements in a ReasonML array must have the same type. See Array.toLocaleString on MDN.

Examples

RESCRIPT
Js.Array.toLocaleString([Js.Date.make()])
// returns "3/19/2020, 10:52:11 AM" for locale en_US.utf8
// returns "2020-3-19 10:52:11" for locale de_DE.utf8

every

RESCRIPT
let every: (t<'a>, 'a => bool) => bool

The first argument to every() is a predicate function that returns a boolean. The every() function returns true if the predicate function is true for all items in the given array. If given an empty array, returns true. See Array.every on MDN.

Examples

RESCRIPT
let isEven = x => mod(x, 2) == 0
Js.Array.every(isEven, [6, 22, 8, 4]) == true
Js.Array.every(isEven, [6, 22, 7, 4]) == false

every

RESCRIPT
let every: ('a => bool, t<'a>) => bool

everyi

RESCRIPT
let everyi: (t<'a>, ('a, int) => bool) => bool

The first argument to everyi() is a predicate function with two arguments: an array element and that element’s index; it returns a boolean. The everyi() function returns true if the predicate function is true for all items in the given array. If given an empty array, returns true. See Array.every on MDN.

Examples

RESCRIPT
// determine if all even-index items are positive
let evenIndexPositive = (item, index) => mod(index, 2) == 0 ? item > 0 : true

Js.Array.everyi(evenIndexPositive, [6, -3, 5, 8]) == true
Js.Array.everyi(evenIndexPositive, [6, 3, -5, 8]) == false

everyi

RESCRIPT
let everyi: (('a, int) => bool, t<'a>) => bool

filter

RESCRIPT
let filter: (t<'a>, 'a => bool) => 'this

Applies the given predicate function to each element in the array; the result is an array of those elements for which the predicate function returned true. See Array.filter on MDN.

Examples

RESCRIPT
let nonEmpty = s => s != ""
Js.Array.filter(nonEmpty, ["abc", "", "", "def", "ghi"]) == ["abc", "def", "ghi"]

filter

RESCRIPT
let filter: ('a => bool, t<'a>) => 'b

filteri

RESCRIPT
let filteri: (t<'a>, ('a, int) => bool) => 'this

Each element of the given array are passed to the predicate function. The return value is an array of all those elements for which the predicate function returned true. See Array.filter on MDN.

Examples

RESCRIPT
// keep only positive elements at odd indices
let positiveOddElement = (item, index) => mod(index, 2) == 1 && item > 0

Js.Array.filteri(positiveOddElement, [6, 3, 5, 8, 7, -4, 1]) == [3, 8]

filteri

RESCRIPT
let filteri: (('a, int) => bool, t<'a>) => 'b

find

RESCRIPT
let find: (t<'a>, 'a => bool) => option<'a>

Returns Some(value) for the first element in the array that satisifies the given predicate function, or None if no element satisifies the predicate. See Array.find on MDN.

Examples

RESCRIPT
// find first negative element
Js.Array.find(x => x < 0, [33, 22, -55, 77, -44]) == Some(-55)
Js.Array.find(x => x < 0, [33, 22, 55, 77, 44]) == None

find

RESCRIPT
let find: ('a => bool, t<'a>) => option<'a>

findi

RESCRIPT
let findi: (t<'a>, ('a, int) => bool) => option<'a>

Returns Some(value) for the first element in the array that satisifies the given predicate function, or None if no element satisifies the predicate. The predicate function takes an array element and an index as its parameters. See Array.find on MDN.

Examples

RESCRIPT
// find first positive item at an odd index
let positiveOddElement = (item, index) => mod(index, 2) == 1 && item > 0

Js.Array.findi(positiveOddElement, [66, -33, 55, 88, 22]) == Some(88)
Js.Array.findi(positiveOddElement, [66, -33, 55, -88, 22]) == None

findi

RESCRIPT
let findi: (('a, int) => bool, t<'a>) => option<'a>

findIndex

RESCRIPT
let findIndex: (t<'a>, 'a => bool) => int

Returns the index of the first element in the array that satisifies the given predicate function, or -1 if no element satisifies the predicate. See Array.find on MDN.

Examples

RESCRIPT
Js.Array.findIndex(x => x < 0, [33, 22, -55, 77, -44]) == 2
Js.Array.findIndex(x => x < 0, [33, 22, 55, 77, 44]) == -1

findIndex

RESCRIPT
let findIndex: ('a => bool, t<'a>) => int

findIndexi

RESCRIPT
let findIndexi: (t<'a>, ('a, int) => bool) => int

Returns Some(value) for the first element in the array that satisifies the given predicate function, or None if no element satisifies the predicate. The predicate function takes an array element and an index as its parameters. See Array.find on MDN.

Examples

RESCRIPT
// find index of first positive item at an odd index
let positiveOddElement = (item, index) => mod(index, 2) == 1 && item > 0

Js.Array.findIndexi(positiveOddElement, [66, -33, 55, 88, 22]) == 3
Js.Array.findIndexi(positiveOddElement, [66, -33, 55, -88, 22]) == -1

findIndexi

RESCRIPT
let findIndexi: (('a, int) => bool, t<'a>) => int

forEach

RESCRIPT
let forEach: (t<'a>, 'a => unit) => unit

The forEach() function applies the function given as the first argument to each element in the array. The function you provide returns unit, and the forEach() function also returns unit. You use forEach() when you need to process each element in the array but not return any new array or value; for example, to print the items in an array. See Array.forEach on MDN.

Examples

RESCRIPT
// display all elements in an array
Js.Array.forEach(x => Js.log(x), ["a", "b", "c"]) == ()

forEach

RESCRIPT
let forEach: ('a => unit, t<'a>) => unit

forEachi

RESCRIPT
let forEachi: (t<'a>, ('a, int) => unit) => unit

The forEachi() function applies the function given as the first argument to each element in the array. The function you provide takes an item in the array and its index number, and returns unit. The forEachi() function also returns unit. You use forEachi() when you need to process each element in the array but not return any new array or value; for example, to print the items in an array. See Array.forEach on MDN.

Examples

RESCRIPT
// display all elements in an array as a numbered list
Js.Array.forEachi((item, index) => Js.log2(index + 1, item), ["a", "b", "c"]) == ()

forEachi

RESCRIPT
let forEachi: (('a, int) => unit, t<'a>) => unit

map

RESCRIPT
let map: (t<'a>, 'a => 'b) => t<'b>

Applies the function (given as the first argument) to each item in the array, returning a new array. The result array does not have to have elements of the same type as the input array. See Array.map on MDN.

Examples

RESCRIPT
Js.Array.map(x => x * x, [12, 4, 8]) == [144, 16, 64]
Js.Array.map(Js.String.length, ["animal", "vegetable", "mineral"]) == [6, 9, 7]

map

RESCRIPT
let map: ('a => 'b, t<'a>) => t<'b>

mapi

RESCRIPT
let mapi: (t<'a>, ('a, int) => 'b) => t<'b>

Applies the function (given as the first argument) to each item in the array, returning a new array. The function acceps two arguments: an item from the array and its index number. The result array does not have to have elements of the same type as the input array. See Array.map on MDN.

Examples

RESCRIPT
// multiply each item in array by its position
let product = (item, index) => item * index
Js.Array.mapi(product, [10, 11, 12]) == [0, 11, 24]

mapi

RESCRIPT
let mapi: (('a, int) => 'b, t<'a>) => t<'b>

reduce

RESCRIPT
let reduce: (t<'a>, ('b, 'a) => 'b, 'b) => 'b

The reduce() function takes three parameters: a reducer function, a beginning accumulator value, and an array. The reducer function has two parameters: an accumulated value and an element of the array.

reduce() first calls the reducer function with the beginning value and the first element in the array. The result becomes the new accumulator value, which is passed in to the reducer function along with the second element in the array. reduce() proceeds through the array, passing in the result of each stage as the accumulator to the reducer function.

When all array elements are processed, the final value of the accumulator becomes the return value of reduce(). See Array.reduce on MDN.

Examples

RESCRIPT
let sumOfSquares = (accumulator, item) => accumulator + item * item

Js.Array.reduce(sumOfSquares, 0, [10, 2, 4]) == 120
Js.Array.reduce(\"*", 1, [10, 2, 4]) == 80
Js.Array.reduce(
  (acc, item) => acc + Js.String.length(item),
  0,
  ["animal", "vegetable", "mineral"],
) == 22 // 6 + 9 + 7
Js.Array.reduce((acc, item) => item /. acc, 1.0, [2.0, 4.0]) == 2.0 // 4.0 / (2.0 / 1.0)

reduce

RESCRIPT
let reduce: (('a, 'b) => 'a, 'a, t<'b>) => 'a

reducei

RESCRIPT
let reducei: (t<'a>, ('b, 'a, int) => 'b, 'b) => 'b

The reducei() function takes three parameters: a reducer function, a beginning accumulator value, and an array. The reducer function has three parameters: an accumulated value, an element of the array, and the index of that element.

reducei() first calls the reducer function with the beginning value, the first element in the array, and zero (its index). The result becomes the new accumulator value, which is passed to the reducer function along with the second element in the array and one (its index). reducei() proceeds from left to right through the array, passing in the result of each stage as the accumulator to the reducer function.

When all array elements are processed, the final value of the accumulator becomes the return value of reducei(). See Array.reduce on MDN.

Examples

RESCRIPT
// find sum of even-index elements in array
let sumOfEvens = (accumulator, item, index) =>
  if mod(index, 2) == 0 {
    accumulator + item
  } else {
    accumulator
  }

Js.Array.reducei(sumOfEvens, 0, [2, 5, 1, 4, 3]) == 6

reducei

RESCRIPT
let reducei: (('a, 'b, int) => 'a, 'a, t<'b>) => 'a

reduceRight

RESCRIPT
let reduceRight: (t<'a>, ('b, 'a) => 'b, 'b) => 'b

The reduceRight() function takes three parameters: a reducer function, a beginning accumulator value, and an array. The reducer function has two parameters: an accumulated value and an element of the array.

reduceRight() first calls the reducer function with the beginning value and the last element in the array. The result becomes the new accumulator value, which is passed in to the reducer function along with the next-to-last element in the array. reduceRight() proceeds from right to left through the array, passing in the result of each stage as the accumulator to the reducer function.

When all array elements are processed, the final value of the accumulator becomes the return value of reduceRight(). See Array.reduceRight on MDN.

NOTE: In many cases, reduce() and reduceRight() give the same result. However, see the last example here and compare it to the example from reduce(), where order makes a difference.

Examples

RESCRIPT
let sumOfSquares = (accumulator, item) => accumulator + item * item

Js.Array.reduceRight(sumOfSquares, 0, [10, 2, 4]) == 120
Js.Array.reduceRight((acc, item) => item /. acc, 1.0, [2.0, 4.0]) == 0.5 // 2.0 / (4.0 / 1.0)

reduceRight

RESCRIPT
let reduceRight: (('a, 'b) => 'a, 'a, t<'b>) => 'a

reduceRighti

RESCRIPT
let reduceRighti: (t<'a>, ('b, 'a, int) => 'b, 'b) => 'b

The reduceRighti() function takes three parameters: a reducer function, a beginning accumulator value, and an array. The reducer function has three parameters: an accumulated value, an element of the array, and the index of that element. reduceRighti() first calls the reducer function with the beginning value, the last element in the array, and its index (length of array minus one). The result becomes the new accumulator value, which is passed in to the reducer function along with the second element in the array and one (its index). reduceRighti() proceeds from right to left through the array, passing in the result of each stage as the accumulator to the reducer function.

When all array elements are processed, the final value of the accumulator becomes the return value of reduceRighti(). See Array.reduceRight on MDN.

NOTE: In many cases, reducei() and reduceRighti() give the same result. However, there are cases where the order in which items are processed makes a difference.

Examples

RESCRIPT
// find sum of even-index elements in array
let sumOfEvens = (accumulator, item, index) =>
  if mod(index, 2) == 0 {
    accumulator + item
  } else {
    accumulator
  }

Js.Array.reduceRighti(sumOfEvens, 0, [2, 5, 1, 4, 3]) == 6

reduceRighti

RESCRIPT
let reduceRighti: (('a, 'b, int) => 'a, 'a, t<'b>) => 'a

some

RESCRIPT
let some: (t<'a>, 'a => bool) => bool

Returns true if the predicate function given as the first argument to some() returns true for any element in the array; false otherwise.

Examples

RESCRIPT
let isEven = x => mod(x, 2) == 0

Js.Array.some(isEven, [3, 7, 5, 2, 9]) == true
Js.Array.some(isEven, [3, 7, 5, 1, 9]) == false

some

RESCRIPT
let some: ('a => bool, t<'a>) => bool

somei

RESCRIPT
let somei: (t<'a>, ('a, int) => bool) => bool

Returns true if the predicate function given as the first argument to somei() returns true for any element in the array; false otherwise. The predicate function has two arguments: an item from the array and the index value

Examples

RESCRIPT
// Does any string in the array
// have the same length as its index?

let sameLength = (str, index) => Js.String.length(str) == index

// "ef" has length 2 and is it at index 2
Js.Array.somei(sameLength, ["ab", "cd", "ef", "gh"]) == true
// no item has the same length as its index
Js.Array.somei(sameLength, ["a", "bc", "def", "gh"]) == false

somei

RESCRIPT
let somei: (('a, int) => bool, t<'a>) => bool

unsafe_get

RESCRIPT
let unsafe_get: (array<'a>, int) => 'a

Returns the value at the given position in the array if the position is in bounds; returns the JavaScript value undefined otherwise.

Examples

RESCRIPT
let arr = [100, 101, 102, 103]
Js.Array.unsafe_get(arr, 3) == 103
Js.Array.unsafe_get(arr, 4) // returns undefined

unsafe_set

RESCRIPT
let unsafe_set: (array<'a>, int, 'a) => unit

Sets the value at the given position in the array if the position is in bounds. If the index is out of bounds, well, “here there be dragons.“ This function modifies the original array.

Examples

RESCRIPT
let arr = [100, 101, 102, 103]
Js.Array.unsafe_set(arr, 3, 99)
// result is [100, 101, 102, 99]

Js.Array.unsafe_set(arr, 4, 88)
// result is [100, 101, 102, 99, 88]

Js.Array.unsafe_set(arr, 6, 77)
// result is [100, 101, 102, 99, 88, <1 empty item>, 77]

Js.Array.unsafe_set(arr, -1, 66)
// you don't want to know.