Module Std.Vector

Resizable Array.

Resizable arrays with a logarithmic push_back in the style of C++. A user need to provide a default value (c.f., DefaultConstructible requirement in C++ version).

type 'a t = 'a vector

a type of vector holding elements of type 'a

include Core_kernel.Bin_prot.Binable.S1 with type 'a t := 'a t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ( 'a, 'a t ) Bin_prot.Size.sizer1
val bin_write_t : ( 'a, 'a t ) Bin_prot.Write.writer1
val bin_read_t : ( 'a, 'a t ) Bin_prot.Read.reader1
val __bin_read_t__ : ( 'a, int -> 'a t ) Bin_prot.Read.reader1
val bin_writer_t : ( 'a, 'a t ) Bin_prot.Type_class.S1.writer
val bin_reader_t : ( 'a, 'a t ) Bin_prot.Type_class.S1.reader
val bin_t : ( 'a, 'a t ) Bin_prot.Type_class.S1.t
val compare : ( 'a -> 'a -> int ) -> 'a t -> 'a t -> int
include Ppx_sexp_conv_lib.Sexpable.S1 with type 'a t := 'a t
val t_of_sexp : ( Sexplib0__.Sexp.t -> 'a ) -> Sexplib0__.Sexp.t -> 'a t
val sexp_of_t : ( 'a -> Sexplib0__.Sexp.t ) -> 'a t -> Sexplib0__.Sexp.t
val create : ?capacity:int -> 'a -> 'a t

create ?capacity default creates an empty vector with a a given capacity. It is guaranteed that the default value will never be seen by the user unless he put it into the vector explicitly with append or set.

val append : 'a t -> 'a -> unit

append xs x appends x to the end of xs

val nth : 'a t -> int -> 'a option

nth vec n returns n'th element of vector vec

val get : 'a t -> int -> 'a

get vec n like nth but raises exception if index is out of bounds

val set : 'a t -> int -> 'a -> unit

set vec n x sets n'th element of a vector vec to x if n < length vec then raises exception

val map_to_array : 'a t -> f:( 'a -> 'b ) -> 'b array

map_to_array xs ~f copies data from xs to an array applying f to each element. See also to_array function from Container.S1 interface

val findi : 'a t -> f:( int -> 'a -> bool ) -> (int * 'a) option

findi xs ~f returns an index i and a value x of the first element of xs, for which f i x is true.

val iteri : 'a t -> f:( int -> 'a -> unit ) -> unit

iter xs ~f applies f i x for each x_i in xs

val foldi : 'a t -> init:'b -> f:( int -> 'b -> 'a -> 'b ) -> 'b

foldi xs ~init:s_0 ~f computes f n s_n x_n, where s_n = f (n-1) s_[n-1] x_[n-1] and n is the number of elements in xs

val index : ?equal:( 'a -> 'a -> bool ) -> 'a t -> 'a -> int option

index ?equal xs x returns an index of the first element p of xs for which equal p x is true. The equal parameter defaults to the OCaml builtin polymorphic equality.

val index_exn : ?equal:( 'a -> 'a -> bool ) -> 'a t -> 'a -> int

index_exn ?equal xs x is the same as index ?equal xs x but an exception is thrown instead of None

val index_with : ?equal:( 'a -> 'a -> bool ) -> default:int -> 'a t -> 'a -> int

index_with ?equal ~default xs x same as index but returns the default value instead of None.

implements common accessors for the array, like find, fold, iter, etc

include Core_kernel.Container.S1 with type 'a t := 'a t
val mem : 'a t -> 'a -> equal:( 'a -> 'a -> bool ) -> bool
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:( 'a -> unit ) -> unit
val fold : 'a t -> init:'accum -> f:( 'accum -> 'a -> 'accum ) -> 'accum
val fold_result : 'a t -> init:'accum -> f:( 'accum -> 'a -> ( 'accum, 'e ) Base__.Result.t ) -> ( 'accum, 'e ) Base__.Result.t
val fold_until : 'a t -> init:'accum -> f: ( 'accum -> 'a -> ( 'accum, 'final ) Base__.Container_intf.Continue_or_stop.t ) -> finish:( 'accum -> 'final ) -> 'final
val exists : 'a t -> f:( 'a -> bool ) -> bool
val for_all : 'a t -> f:( 'a -> bool ) -> bool
val count : 'a t -> f:( 'a -> bool ) -> int
val sum : (module Base__.Container_intf.Summable with type t = 'sum) -> 'a t -> f:( 'a -> 'sum ) -> 'sum
val find : 'a t -> f:( 'a -> bool ) -> 'a option
val find_map : 'a t -> f:( 'a -> 'b option ) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> compare:( 'a -> 'a -> int ) -> 'a option
val max_elt : 'a t -> compare:( 'a -> 'a -> int ) -> 'a option
val pp : ( Stdlib.Format.formatter -> 'a -> unit ) -> Stdlib.Format.formatter -> 'a t -> unit

pp pp_elem creates a vector printer that uses pp_elem to print elements.