`CCVector`

Growable, mutable vector

Mutability is `rw`

(read-write) or `ro`

(read-only).

Make an immutable vector (no copy! Don't use the old version).

Create a new vector, the value is used to enforce the type the new vector.

`val return : 'a -> ( 'a, 'mut ) t`

Singleton vector.

`val make : int -> 'a -> ( 'a, 'mut ) t`

`make n x`

makes a vector of size `n`

, filled with `x`

.

`val init : int -> ( int -> 'a ) -> ( 'a, 'mut ) t`

Init the vector with the given function and size.

Clear the content of the vector. This ensures that `length v = 0`

but the underlying array is kept, and possibly references to former elements, which are therefore not garbage collectible.

Clear the content of the vector, and deallocate the underlying array, removing references to all the elements. The elements can be collected.

Hint to the vector that it should have at least the given capacity. This does not affect `length v`

.

Hint to the vector that it should have at least the given capacity. Just a hint, will not be enforced if the vector is empty and `init`

is not provided.

`val is_empty : ( 'a, _ ) t -> bool`

Is the vector empty?

`resize_with vec f size`

resizes vector `vec`

up to `size`

, fills vector with calls to `f`

on indexes `[vec.size-1.. size - 1]`

. The contents and size of vec are untouched if `size`

is inferior or equal to `length vec`

.

`resize_with_init vec init size`

resizes vector `vec`

up to `size`

, fills vector with calls to `init`

on indexes `[length vec -1.. size - 1]`

. The contents and size of vec are untouched if `size`

is inferior or equal to `length vec`

.

Append content of iterator. Renamed from `append_std_seq`

since 3.0.

`val top : ( 'a, _ ) t -> 'a option`

Top element, if present.

`val top_exn : ( 'a, _ ) t -> 'a`

Top element, if present.

Truncate to the given size (remove elements above this size). Does nothing if the parameter is bigger than the current size. `truncate`

was called `shrink`

.

`val shrink_to_fit : ( 'a, _ ) t -> unit`

Shrink internal array to fit the size of the vector

`val member : eq:( 'a -> 'a -> bool ) -> 'a -> ( 'a, _ ) t -> bool`

Is the element a member of the vector?

Sort the vector, returning a copy of it that is sorted w.r.t the given ordering. The vector itself is unchanged. The underlying array of the new vector can be smaller than the original one.

Sort the vector in place (modifying it). This function change the size of the underlying array.

Sort the array and remove duplicates, in place (e.g. modifying the vector itself).

`val iter : ( 'a -> unit ) -> ( 'a, _ ) t -> unit`

Iterate on the vector's content.

`val iteri : ( int -> 'a -> unit ) -> ( 'a, _ ) t -> unit`

Iterate on the vector, with indexes.

Map elements of the vector, yielding a new vector.

`map f v`

is just like `map`

, but it also passes in the index of each element as the first argument to the function `f`

.

`val map_in_place : ( 'a -> 'a ) -> ( 'a, _ ) t -> unit`

Map elements of the vector in place

Filter elements from the vector. `filter p v`

leaves `v`

unchanged but returns a new vector that only contains elements of `v`

satisfying `p`

.

Filter elements from the vector in place.

`val fold : ( 'b -> 'a -> 'b ) -> 'b -> ( 'a, _ ) t -> 'b`

Fold on elements of the vector

`val exists : ( 'a -> bool ) -> ( 'a, _ ) t -> bool`

Existential test (is there an element that satisfies the predicate?).

`val for_all : ( 'a -> bool ) -> ( 'a, _ ) t -> bool`

Universal test (do all the elements satisfy the predicate?).

`val find : ( 'a -> bool ) -> ( 'a, _ ) t -> 'a option`

Find an element that satisfies the predicate.

`val find_exn : ( 'a -> bool ) -> ( 'a, _ ) t -> 'a`

Find an element that satisfies the predicate, or

`val find_map : ( 'a -> 'b option ) -> ( 'a, _ ) t -> 'b option`

`find_map f v`

returns the first `Some y = f x`

for `x`

in `v`

, or `None`

if `f x = None`

for each `x`

in `v`

.

Map elements with a function, possibly filtering some of them out.

`val filter_map_in_place : ( 'a -> 'a option ) -> ( 'a, _ ) t -> unit`

Filter-map elements of the vector in place

Map each element to a sub-vector.

Like `flat_map`

, but using `Seq`

for intermediate collections. Renamed from `flat_map_std_seq`

since 3.0.

Like `flat_map`

, but using `list`

for intermediate collections.

All combinaisons of tuples from the two vectors are passed to the function.

`val get : ( 'a, _ ) t -> int -> 'a`

Access element by its index, or

`remove_and_shift v i`

remove the `i-th`

element from `v`

. Move elements that are after the `i-th`

in `v`

, in linear time. Preserve the order of the elements in `v`

. See `remove_unordered`

for constant time removal function that doesn't preserve the order of elements.

`remove_unordered v i`

remove the `i-th`

element from `v`

. Does **NOT** preserve the order of the elements in `v`

(might swap with the last element). See `remove_and_shift`

if you want to keep the ordering.

`insert v i x`

insert the given element at index i. Elements at location `i`

and later are first shifted over in linear time before inserting `x`

. Preserve the order of elements in `v`

.

`val rev_iter : ( 'a -> unit ) -> ( 'a, _ ) t -> unit`

`rev_iter f a`

is the same as `iter f (rev a)`

, only more efficient.

`val size : ( 'a, _ ) t -> int`

Number of elements in the vector.

`val capacity : ( _, _ ) t -> int`

Number of elements the vector can contain without being resized.

Access the underlying **shared** array (do not modify!). `unsafe_get_array v`

is longer than `size v`

, but elements at higher index than `size v`

are undefined (do not access!).

`val (--) : int -> int -> ( int, 'mut ) t`

Range of integers, either ascending or descending (both included, therefore the result is never empty). Example: `1 -- 10`

returns the vector `[1;2;3;4;5;6;7;8;9;10]`

.

`val (--^) : int -> int -> ( int, 'mut ) t`

Range of integers, either ascending or descending, but excluding right. Example: `1 --^ 10`

returns the vector `[1;2;3;4;5;6;7;8;9]`

.

`val of_array : 'a array -> ( 'a, 'mut ) t`

`of_array a`

returns a vector corresponding to the array `a`

. Operates in `O(n)`

time.

`val of_list : 'a list -> ( 'a, 'mut ) t`

`val to_array : ( 'a, _ ) t -> 'a array`

`to_array v`

returns an array corresponding to the vector `v`

.

`val to_list : ( 'a, _ ) t -> 'a list`

Return a list with the elements contained in the vector.

Convert an Iterator to a vector. Renamed from `of_std_seq`

since 3.0.

`to_iter_rev v`

returns the sequence of elements of `v`

in reverse order, that is, the last elements of `v`

are iterated on first.

`val to_seq : ( 'a, _ ) t -> 'a Stdlib.Seq.t`

Return an iterator with the elements contained in the vector. Renamed from `to_std_seq`

since 3.0.

`val to_seq_rev : ( 'a, _ ) t -> 'a Stdlib.Seq.t`

`to_seq v`

returns the sequence of elements of `v`

in reverse order, that is, the last elements of `v`

are iterated on first. Renamed from `to_std_seq`

since 3.0.

Vector as an array slice. By doing it we expose the internal array, so be careful!.

`slice_iter v start len`

is the sequence of elements from `v.(start)`

to `v.(start+len-1)`

.

```
val to_string :
?start:string ->
?stop:string ->
?sep:string ->
( 'a -> string ) ->
( 'a, _ ) t ->
string
```

Print the vector in a string

```
val pp :
?pp_start:unit printer ->
?pp_stop:unit printer ->
?pp_sep:unit printer ->
'a printer ->
( 'a, _ ) t printer
```

`pp ~pp_start ~pp_stop ~pp_sep pp_item ppf v`

formats the vector `v`

on `ppf`

. Each element is formatted with `pp_item`

, `pp_start`

is called at the beginning, `pp_stop`

is called at the end, `pp_sep`

is called between each elements. By defaults `pp_start`

and `pp_stop`

does nothing and `pp_sep`

defaults to (fun out -> Format.fprintf out ",@ ").