module Vector: CCVector
type [ `RO ]
type [ `RW ]
Mutability is rw (read-write) or ro (read-only)
type ('a, 'mut) t
The type of a vector of elements of type 'a, with
a mutability flat 'mut
type 'a vector = ('a, rw) t
Type synonym: a 'a vector is mutable.
type 'a ro_vector = ('a, ro) t
Alias for immutable vectors.
Since 0.15
type 'a sequence = ('a -> unit) -> unit
type 'a klist = unit -> [ `Cons of 'a * 'a klist | `Nil ]
type 'a gen = unit -> 'a option
type 'a equal = 'a -> 'a -> bool
type 'a ord = 'a -> 'a -> int
type 'a printer = Buffer.t -> 'a -> unit
type 'a formatter = Format.formatter -> 'a -> unit
val freeze : ('a, 'b) t -> ('a, ro) t
Make an immutable vector (no copy! Don't use the old version)
val freeze_copy : ('a, 'b) t -> ('a, ro) t
Copy the vector into an immutable version
val create : unit -> ('a, rw) t
Create a new, empty vector
val create_with : ?capacity:int -> 'a -> ('a, rw) t
Create a new vector, using the given value as a filler.
capacity : the size of the underlying array
caution: the value will likely not be GC'd before the vector is.
val return : 'a -> ('a, 'mut) t
Singleton vector
Since 0.14
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
val clear : ('a, rw) t -> unit
Clear the content of the vector
val ensure_with : init:'a -> ('a, rw) t -> int -> unit
Hint to the vector that it should have at least the given capacity.
Since 0.14
init : if
capacity v = 0, used as a filler
element for the underlying array (see
CCVector.create_with)
val ensure : ('a, rw) t -> int -> unit
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, 'b) t -> bool
Is the vector empty?
val push : ('a, rw) t -> 'a -> unit
Add an element at the end of the vector
val append : ('a, rw) t -> ('a, 'b) t -> unit
append a b adds all elements of b to a
val append_array : ('a, rw) t -> 'a array -> unit
Same as append, with an array
val append_seq : ('a, rw) t -> 'a sequence -> unit
Append content of sequence
val append_list : ('a, rw) t -> 'a list -> unit
Append content of list
Since 0.14
val append_gen : ('a, rw) t -> 'a gen -> unit
Append content of generator
Since 0.20
val equal : 'a equal -> ('a, 'b) t equal
val compare : 'a ord -> ('a, 'b) t ord
Total ordering on vectors. Lexicographic comparison.
exception Empty
Raised on empty stack
val pop : ('a, rw) t -> 'a option
Remove last element, or None
val pop_exn : ('a, rw) t -> 'a
Remove last element, or raise a Failure if empty
Raises Empty on an empty vector
val top : ('a, 'b) t -> 'a option
Top element, if present
Since 0.6
val top_exn : ('a, 'b) t -> 'a
Top element, if present
Since 0.6
Raises Empty on an empty vector
val copy : ('a, 'b) t -> ('a, 'mut) t
Shallow copy (may give an immutable or mutable vector)
val shrink : ('a, rw) t -> int -> unit
Shrink to the given size (remove elements above this size).
Does nothing if the parameter is bigger than the current size.
val member : ?eq:('a -> 'a -> bool) -> 'a -> ('a, 'b) t -> bool
Is the element a member of the vector?
val sort : ('a -> 'a -> int) -> ('a, 'b) t -> ('a, 'mut) t
Sort the vector, returning a copy of it that is sorted
w.r.t the given ordering. The vector itself is unchanged.
val sort' : ('a -> 'a -> int) -> ('a, rw) t -> unit
Sort the vector in place (modifying it).
val uniq_sort : ('a -> 'a -> int) -> ('a, rw) t -> unit
Sort the array and remove duplicates, in place (e.g. modifying
the vector itself)
val iter : ('a -> unit) -> ('a, 'b) t -> unit
Iterate on the vector's content
val iteri : (int -> 'a -> unit) -> ('a, 'b) t -> unit
Iterate on the vector, with indexes
val map : ('a -> 'b) -> ('a, 'c) t -> ('b, 'mut) t
Map elements of the vector, yielding a new vector
val filter : ('a -> bool) -> ('a, 'b) t -> ('a, 'mut) t
Filter elements from the vector. filter p v leaves v unchanged but
returns a new vector that only contains elements of v satisfying p.
val filter' : ('a -> bool) -> ('a, rw) t -> unit
Filter elements in place.
val fold : ('b -> 'a -> 'b) -> 'b -> ('a, 'c) t -> 'b
Fold on elements of the vector
val exists : ('a -> bool) -> ('a, 'b) t -> bool
Existential test (is there an element that satisfies the predicate?)
val for_all : ('a -> bool) -> ('a, 'b) t -> bool
Universal test (do all the elements satisfy the predicate?)
val find : ('a -> bool) -> ('a, 'b) t -> 'a option
Find an element that satisfies the predicate
val find_exn : ('a -> bool) -> ('a, 'b) t -> 'a
Find an element that satisfies the predicate, or
Raises Not_found if no element does
val find_map : ('a -> 'b option) -> ('a, 'c) 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
Since 0.14
val filter_map : ('a -> 'b option) -> ('a, 'c) t -> ('b, 'mut) t
Map elements with a function, possibly filtering some of them out
val flat_map : ('a -> ('b, 'c) t) -> ('a, 'd) t -> ('b, 'mut) t
Map each element to a sub-vector
val flat_map_seq : ('a -> 'b sequence) -> ('a, 'c) t -> ('b, 'mut) t
val flat_map_list : ('a -> 'b list) -> ('a, 'c) t -> ('b, 'mut) t
val flat_map' : ('a -> 'b sequence) -> ('a, 'c) t -> ('b, 'mut) t
val (>>=) : ('a, 'c) t -> ('a -> ('b, 'd) t) -> ('b, 'mut) t
val (>|=) : ('a, 'c) t -> ('a -> 'b) -> ('b, 'mut) t
val get : ('a, 'b) t -> int -> 'a
Access element by its index, or
Raises Invalid_argument if bad index
val set : ('a, rw) t -> int -> 'a -> unit
Modify element at given index, or
Raises Invalid_argument if bad index
val remove : ('a, rw) t -> int -> unit
Remove the n-th element of the vector. Does NOT preserve the order
of the elements (might swap with the last element)
val rev : ('a, 'b) t -> ('a, 'mut) t
Reverse the vector
val rev_in_place : ('a, rw) t -> unit
Reverse the vector in place
Since 0.14
val rev' : ('a, rw) t -> unit
val rev_iter : ('a -> unit) -> ('a, 'b) t -> unit
rev_iter f a is the same as iter f (rev a), only more efficient.
Since 0.14
val size : ('a, 'b) t -> int
Number of elements in vector
val length : ('a, 'b) t -> int
val capacity : ('a, 'b) t -> int
Number of elements the vector can contain without being resized
val unsafe_get_array : ('a, rw) t -> 'a array
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]
Since 0.17
val of_array : 'a array -> ('a, 'mut) t
val of_list : 'a list -> ('a, 'mut) t
val to_array : ('a, 'b) t -> 'a array
val to_list : ('a, 'b) t -> 'a list
val of_seq : ?init:('a, rw) t ->
'a sequence -> ('a, rw) t
val to_seq : ('a, 'b) t -> 'a sequence
val to_seq_rev : ('a, 'b) t -> 'a sequence
to_seq_rev v returns the sequence of elements of v in reverse order,
that is, the last elements of v are iterated on first.
Since 0.14
val slice : ('a, rw) t -> 'a array * int * int
Vector as an array slice. By doing it we expose the internal array, so
be careful!
val slice_seq : ('a, 'b) t -> int -> int -> 'a sequence
slice_seq v start len is the sequence of elements from v.(start)
to v.(start+len-1).
val of_klist : ?init:('a, rw) t ->
'a klist -> ('a, rw) t
val to_klist : ('a, 'b) t -> 'a klist
val of_gen : ?init:('a, rw) t ->
'a gen -> ('a, rw) t
val to_gen : ('a, 'b) t -> 'a gen
val pp : ?start:string ->
?stop:string ->
?sep:string -> 'a printer -> ('a, 'b) t printer
val print : ?start:string ->
?stop:string ->
?sep:string ->
'a formatter -> ('a, 'b) t formatter