Vector

t

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

filterInPlace

RE
let filterInPlace: ((. 'a) => bool, t('a)) => unit;

p : predicate a : array

empty

RE
let empty: t('a) => unit;

pushBack

RE
let pushBack: ('a, t('a)) => unit;

copy

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

Create a shallow copy of a vector.

memByRef

RE
let memByRef: ('a, t('a)) => bool;

Find by JS (===) equality.

iter

RE
let iter: ((. 'a) => unit, t('a)) => unit;

iteri

RE
let iteri: ((. int, 'a) => unit, t('a)) => unit;

toList

RE
let toList: t('a) => list('a);

map

RE
let map: ((. 'a) => 'b, t('a)) => t('b);

mapi

RE
let mapi: ((. int, 'a) => 'b, t('a)) => t('b);

foldLeft

RE
let foldLeft: ((. 'a, 'b) => 'a, 'a, t('b)) => 'a;

foldRight

RE
let foldRight: ((. 'b, 'a) => 'a, t('b), 'a) => 'a;

length

RE
let length: t('a) => int;

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

get

RE
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

RE
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

RE
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

RE
let init: (int, (. int) => 'a) => t('a);

Raises RangeError when n is negative. n : size

append

RE
let append: ('a, t('a)) => t('a);

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

unsafe_get

RE
let unsafe_get: (t('a), int) => 'a;

unsafe_set

RE
let unsafe_set: (t('a), int, 'a) => unit;