base

Full standard library replacement for OCaml
IN THIS PACKAGE
Module Base . Uniform_array
type 'a t

See Base.Array for comments.

include Sexplib0.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 t_sexp_grammar : 'a Sexplib0.Sexp_grammar.t -> 'a t Sexplib0.Sexp_grammar.t
val compare : ( 'a -> 'a -> int ) -> 'a t -> 'a t -> int
val invariant : _ t -> unit
val empty : _ t
val create : len:int -> 'a -> 'a t
val singleton : 'a -> 'a t
val init : int -> f:( int -> 'a ) -> 'a t
val length : 'a t -> int
val get : 'a t -> int -> 'a
val unsafe_get : 'a t -> int -> 'a
val set : 'a t -> int -> 'a -> unit
val unsafe_set : 'a t -> int -> 'a -> unit
val swap : _ t -> int -> int -> unit
val unsafe_set_omit_phys_equal_check : 'a t -> int -> 'a -> unit

unsafe_set_omit_phys_equal_check is like unsafe_set, except it doesn't do a phys_equal check to try to skip caml_modify. It is safe to call this even if the values are phys_equal.

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

unsafe_set_with_caml_modify always calls caml_modify before setting and never gets the old value. This is like unsafe_set_omit_phys_equal_check except it doesn't check whether the old value and the value being set are integers to try to skip caml_modify.

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

Same as unsafe_set_with_caml_modify, but with bounds check.

val map : 'a t -> f:( 'a -> 'b ) -> 'b t
val mapi : 'a t -> f:( int -> 'a -> 'b ) -> 'b t
val iter : 'a t -> f:( 'a -> unit ) -> unit
val iteri : 'a t -> f:( int -> 'a -> unit ) -> unit

Like iter, but the function is applied to the index of the element as first argument, and the element itself as second argument.

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

of_array and to_array return fresh arrays with the same contents rather than returning a reference to the underlying array.

val to_array : 'a t -> 'a array
val of_list : 'a list -> 'a t
val to_list : 'a t -> 'a list
include Blit.S1 with type 'a t := 'a t
val blit : src:'a t -> src_pos:int -> dst:'a t -> dst_pos:int -> len:int -> unit
val blito : src:'a t -> ?src_pos:int -> ?src_len:int -> dst:'a t -> ?dst_pos:int -> unit -> unit
val unsafe_blit : src:'a t -> src_pos:int -> dst:'a t -> dst_pos:int -> len:int -> unit
val sub : 'a t -> pos:int -> len:int -> 'a t
val subo : ?pos:int -> ?len:int -> 'a t -> 'a t
val copy : 'a t -> 'a t

Extra lowlevel and unsafe functions

val unsafe_create_uninitialized : len:int -> _ t

The behavior is undefined if you access an element before setting it.

val create_obj_array : len:int -> Caml.Obj.t t

New obj array filled with Obj.repr 0

val unsafe_set_assuming_currently_int : Caml.Obj.t t -> int -> Caml.Obj.t -> unit

unsafe_set_assuming_currently_int t i obj sets index i of t to obj, but only works correctly if the value there is an immediate, i.e. Caml.Obj.is_int (get t i). This precondition saves a dynamic check.

unsafe_set_int_assuming_currently_int is similar, except the value being set is an int.

unsafe_set_int is similar but does not assume anything about the target.

val unsafe_set_int_assuming_currently_int : Caml.Obj.t t -> int -> int -> unit
val unsafe_set_int : Caml.Obj.t t -> int -> int -> unit
val unsafe_clear_if_pointer : Caml.Obj.t t -> int -> unit

unsafe_clear_if_pointer t i prevents t.(i) from pointing to anything to prevent space leaks. It does this by setting t.(i) to Caml.Obj.repr 0. As a performance hack, it only does this when not (Caml.Obj.is_int t.(i)). It is an error to access the cleared index before setting it again.

val exists : 'a t -> f:( 'a -> bool ) -> bool

As Array.exists.

val for_all : 'a t -> f:( 'a -> bool ) -> bool

As Array.for_all.

val map2_exn : 'a t -> 'b t -> f:( 'a -> 'b -> 'c ) -> 'c t

Functions with the 2 suffix raise an exception if the lengths of the two given arrays aren't the same.

val min_elt : 'a t -> compare:( 'a -> 'a -> int ) -> 'a option
val max_elt : 'a t -> compare:( 'a -> 'a -> int ) -> 'a option