Module Js.Array

Bindings to the functions in Array.prototype

JavaScript Array API

type 'a t = 'a array

type t('a) = array('a);

type 'a array_like = 'a Js.array_like

type array_like('a) = Js.array_like('a);

val from : 'a array_like -> 'a array

let from: array_like('a) => array('a);

val fromMap : 'a array_like -> f:('a -> 'b) -> 'b array

let fromMap: array_like('a) => f:('a => 'b) => array('b);

val isArray : 'a -> bool

let isArray: 'a => bool;

val length : 'a array -> int

let length: array('a) => int;

Mutating functions

val copyWithin : to_:int -> ?start:int -> ?end_:int -> 'a t -> 'a t

let copyWithin: to_:int => ?start:int => ?end_:int => t('a) => t('a);

val fill : value:'a -> ?start:int -> ?end_:int -> 'a t -> 'a t

let fill: value:'a => ?start:int => ?end_:int => t('a) => t('a);

val flat : 'a t t -> 'a t

let flat: t(t('a)) => t('a);

val pop : 'a t -> 'a option

let pop: t('a) => option('a);

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global\_Objects/Array/pop

val push : value:'a -> 'a t -> int

let push: value:'a => t('a) => int;

val pushMany : values:'a array -> 'a t -> int

let pushMany: values:array('a) => t('a) => int;

val toReversed : 'a t -> 'a t

let toReversed: t('a) => t('a);

returns a new array with the elements in reversed order. (ES2023)

val reverseInPlace : 'a t -> 'a t

let reverseInPlace: t('a) => t('a);

val shift : 'a t -> 'a option

let shift: t('a) => option('a);

val toSorted : 'a t -> 'a t

let toSorted: t('a) => t('a);

returns a new array with the elements sorted in ascending order. (ES2023)

val toSortedWith : f:('a -> 'a -> int) -> 'a t -> 'a t

let toSortedWith: f:('a => 'a => int) => t('a) => t('a);

returns a new array with the elements sorted in ascending order. (ES2023)

val sortInPlace : 'a t -> 'a t

let sortInPlace: t('a) => t('a);

val sortInPlaceWith : f:('a -> 'a -> int) -> 'a t -> 'a t

let sortInPlaceWith: f:('a => 'a => int) => t('a) => t('a);

val spliceInPlace : start:int -> remove:int -> add:'a array -> 'a t -> 'a t

let spliceInPlace: start:int => remove:int => add:array('a) => t('a) => t('a);

changes the contents of the given array by removing or replacing existing elements and/or adding new elements in place. returns a new array containing the removed elements.

val toSpliced : start:int -> remove:int -> add:'a array -> 'a t -> 'a t

let toSpliced: start:int => remove:int => add:array('a) => t('a) => t('a);

returns a new array with some elements removed and/or replaced at a given index. (ES2023)

val removeFromInPlace : start:int -> 'a t -> 'a t

let removeFromInPlace: start:int => t('a) => t('a);

removes all elements from the given array starting at the start index and returns the removed elements.

val removeFrom : start:int -> 'a t -> 'a t

let removeFrom: start:int => t('a) => t('a);

returns a new array with elements removed starting at the start index. (ES2023)

val removeCountInPlace : start:int -> count:int -> 'a t -> 'a t

let removeCountInPlace: start:int => count:int => t('a) => t('a);

removes count elements from the given array starting at the start index and returns the removed elements.

val removeCount : start:int -> count:int -> 'a t -> 'a t

let removeCount: start:int => count:int => t('a) => t('a);

returns a new array with count elements removed starting at the start index. (ES2023)

val unshift : value:'a -> 'a t -> int

let unshift: value:'a => t('a) => int;

val unshiftMany : values:'a array -> 'a t -> int

let unshiftMany: values:array('a) => t('a) => int;

val concat : other:'a t -> 'a t -> 'a t

let concat: other:t('a) => t('a) => t('a);

val concatMany : arrays:'a t array -> 'a t -> 'a t

let concatMany: arrays:array(t('a)) => t('a) => t('a);

val includes : value:'a -> 'a t -> bool

let includes: value:'a => t('a) => bool;

ES2015

val join : ?sep:string -> 'a t -> string

let join: ?sep:string => t('a) => string;

Accessor functions

val at : index:int -> 'a t -> 'a option

let at: index:int => t('a) => option('a);

ES2022

val indexOf : value:'a -> ?start:int -> 'a t -> int

let indexOf: value:'a => ?start:int => t('a) => int;

val lastIndexOf : value:'a -> 'a t -> int

let lastIndexOf: value:'a => t('a) => int;

val lastIndexOfFrom : value:'a -> start:int -> 'a t -> int

let lastIndexOfFrom: value:'a => start:int => t('a) => int;

val copy : 'a t -> 'a t

let copy: t('a) => t('a);

val slice : ?start:int -> ?end_:int -> 'a t -> 'a t

let slice: ?start:int => ?end_:int => t('a) => t('a);

val toString : 'a t -> string

let toString: t('a) => string;

val toLocaleString : 'a t -> string

let toLocaleString: t('a) => string;

Iteration functions

val entries : 'a t -> (int * 'a) Js.iterator

let entries: t('a) => Js.iterator((int, 'a));

val every : f:('a -> bool) -> 'a t -> bool

let every: f:('a => bool) => t('a) => bool;

val everyi : f:('a -> int -> bool) -> 'a t -> bool

let everyi: f:('a => int => bool) => t('a) => bool;

val filter : f:('a -> bool) -> 'a t -> 'a t

let filter: f:('a => bool) => t('a) => t('a);

val filteri : f:('a -> int -> bool) -> 'a t -> 'a t

let filteri: f:('a => int => bool) => t('a) => t('a);

val find : f:('a -> bool) -> 'a t -> 'a option

let find: f:('a => bool) => t('a) => option('a);

val findi : f:('a -> int -> bool) -> 'a t -> 'a option

let findi: f:('a => int => bool) => t('a) => option('a);

val findLast : f:('a -> bool) -> 'a t -> 'a option

let findLast: f:('a => bool) => t('a) => option('a);

val findLasti : f:('a -> int -> bool) -> 'a t -> 'a option

let findLasti: f:('a => int => bool) => t('a) => option('a);

val findIndex : f:('a -> bool) -> 'a t -> int

let findIndex: f:('a => bool) => t('a) => int;

val findIndexi : f:('a -> int -> bool) -> 'a t -> int

let findIndexi: f:('a => int => bool) => t('a) => int;

val findLastIndex : f:('a -> bool) -> 'a t -> int

let findLastIndex: f:('a => bool) => t('a) => int;

val findLastIndexi : f:('a -> int -> bool) -> 'a t -> int

let findLastIndexi: f:('a => int => bool) => t('a) => int;

val forEach : f:('a -> unit) -> 'a t -> unit

let forEach: f:('a => unit) => t('a) => unit;

val forEachi : f:('a -> int -> unit) -> 'a t -> unit

let forEachi: f:('a => int => unit) => t('a) => unit;

val keys : 'a t -> int Js.iterator

let keys: t('a) => Js.iterator(int);

val map : f:('a -> 'b) -> 'a t -> 'b t

let map: f:('a => 'b) => t('a) => t('b);

val mapi : f:('a -> int -> 'b) -> 'a t -> 'b t

let mapi: f:('a => int => 'b) => t('a) => t('b);

val reduce : f:('b -> 'a -> 'b) -> init:'b -> 'a t -> 'b

let reduce: f:('b => 'a => 'b) => init:'b => t('a) => 'b;

val reducei : f:('b -> 'a -> int -> 'b) -> init:'b -> 'a t -> 'b

let reducei: f:('b => 'a => int => 'b) => init:'b => t('a) => 'b;

val reduceRight : f:('b -> 'a -> 'b) -> init:'b -> 'a t -> 'b

let reduceRight: f:('b => 'a => 'b) => init:'b => t('a) => 'b;

val reduceRighti : f:('b -> 'a -> int -> 'b) -> init:'b -> 'a t -> 'b

let reduceRighti: f:('b => 'a => int => 'b) => init:'b => t('a) => 'b;

val some : f:('a -> bool) -> 'a t -> bool

let some: f:('a => bool) => t('a) => bool;

val somei : f:('a -> int -> bool) -> 'a t -> bool

let somei: f:('a => int => bool) => t('a) => bool;

val values : 'a t -> 'a Js.iterator

let values: t('a) => Js.iterator('a);

val unsafe_get : 'a array -> int -> 'a

let unsafe_get: array('a) => int => 'a;

val unsafe_set : 'a array -> int -> 'a -> unit

let unsafe_set: array('a) => int => 'a => unit;