API / Js / Vector

# Vector

Provide vector utilities.

## t

```RES```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
``````