Vector

t

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

filterInPlace

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

p : predicate a : array

empty

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

pushBack

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

copy

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

Create a shallow copy of a vector.

memByRef

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

Find by JS (===) equality.

iter

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

iteri

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

toList

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

map

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

mapi

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

foldLeft

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

foldRight

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

length

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

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

get

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

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

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

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

Raises RangeError when n is negative. n : size

append

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

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

unsafe_get

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

unsafe_set

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