API / Js / Vector

Vector

Provides bindings for JS Vector

t

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

filterInPlace

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

empty

RESCRIPT
let empty: t<'a> => unit

pushBack

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

copy

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

shallow copy

memByRef

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

iter

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

iteri

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

toList

RESCRIPT
let toList: t<'a> => list<'a>

map

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

mapi

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

foldLeft

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

foldRight

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

length

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

Return the length (number of elements) of the given array.

get

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

Vector.get(a, n) returns the element number n of vector a. The first element has number 0. The last element has number Vector.length(a) - 1. You can also write a[n] instead of Vector.get(a, n). Raise Invalid_argument "index out of bounds" if n is outside the range 0 to (Array.length(a) - 1).

set

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

Vector.set(a, n, x) modifies vector a in place, replacing element number n with x. Raise Invalid_argument "index out of bounds" if n is outside the range 0 to Array.length(a) - 1.

make

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

Vector.make(n, x) returns a fresh vector of length n, initialized with x. All the elements of this new vector are initially physically equal to x (in the sense of the == predicate). Consequently, if x is mutable, it is shared among all elements of the array, and modifying x through one of the array entries will modify all other entries at the same time. Raise Invalid_argument if n < 0 or n > Sys.max_array_length. If the value of x is a floating-point number, then the maximum size is only Sys.max_array_length / 2.

init

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

Raises RangeError when n is negative. n : size

append

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

append(x, a) returns a fresh vector with x appended to a.

unsafe_get

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

unsafe_set

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