Documentation
containers lib
CCArray
Module
Array utilstype 'a sequence = ('a -> unit) -> unit
type 'a klist = unit -> [ `Nil | `Cons of 'a * 'a klist ]
type 'a gen = unit -> 'a option
type 'a equal = 'a -> 'a -> bool
type 'a ord = 'a -> 'a -> int
type 'a random_gen = Stdlib .Random.State.t -> 'a
Abstract Signaturemodule type S = sig ... end
Arraysinclude S with type 'a t := 'a t
val get : 'a t -> int -> 'a
val get_safe : 'a t -> int -> 'a option
get_safe a i
returns Some a.(i)
if i
is a valid index
val set : 'a t -> int -> 'a -> unit
val fold : ('a -> 'b -> 'a ) -> 'a -> 'b t -> 'a
val foldi : ('a -> int -> 'b -> 'a ) -> 'a -> 'b t -> 'a
Fold left on array, with index
val fold_while : ('a -> 'b -> 'a * [ `Stop | `Continue ] ) -> 'a -> 'b t -> 'a
Fold left on array until a stop condition via ('a, `Stop)
is indicated by the accumulator
val iter : ('a -> unit) -> 'a t -> unit
val iteri : (int -> 'a -> unit) -> 'a t -> unit
val blit : 'a t -> int -> 'a t -> int -> int -> unit
blit from i into j len
copies len
elements from the first array to the second. See Array.blit
.
val reverse_in_place : 'a t -> unit
Reverse the array in place
val find : ('a -> 'b option ) -> 'a t -> 'b option
find f a
returns Some y
if there is an element x
such that f x = Some y
, else it returns None
val findi : (int -> 'a -> 'b option ) -> 'a t -> 'b option
Like find
, but also pass the index to the predicate function.
val find_idx : ('a -> bool) -> 'a t -> (int * 'a ) option
find_idx p x
returns Some (i,x)
where x
is the i
-th element of l
, and p x
holds. Otherwise returns None
val lookup : ?cmp :'a ord -> 'a -> 'a t -> int option
Lookup the index of some value in a sorted array.
val lookup_exn : ?cmp :'a ord -> 'a -> 'a t -> int
val bsearch :
?cmp :('a -> 'a -> int) ->
'a ->
'a t ->
[ `All_lower | `All_bigger | `Just_after of int | `Empty | `At of int ]
bsearch ?cmp x arr
finds the index of the object x
in the array arr
, provided arr
is sorted using cmp
. If the array is not sorted, the result is not specified (may raise Invalid_argument).
Complexity: O(log n) where n is the length of the array (dichotomic search).
val for_all : ('a -> bool) -> 'a t -> bool
val for_all2 : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
Forall on pairs of arrays.
val exists : ('a -> bool) -> 'a t -> bool
val exists2 : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
Exists on pairs of arrays.
val shuffle : 'a t -> unit
Shuffle randomly the array, in place
val shuffle_with : Stdlib .Random.State.t -> 'a t -> unit
Like shuffle but using a specialized random state
Choose an element randomly.
val to_gen : 'a t -> 'a gen
val to_klist : 'a t -> 'a klist
IOval pp :
?sep :string ->
(Stdlib .Buffer.t -> 'a -> unit) ->
Stdlib .Buffer.t ->
'a t ->
unit
Print an array of items with printing function
val pp_i :
?sep :string ->
(Stdlib .Buffer.t -> int -> 'a -> unit) ->
Stdlib .Buffer.t ->
'a t ->
unit
Print an array, giving the printing function both index and item
val print :
?sep :string ->
(Stdlib .Format.formatter -> 'a -> unit) ->
Stdlib .Format.formatter ->
'a t ->
unit
Print an array of items with printing function
val map : ('a -> 'b ) -> 'a t -> 'b t
val filter : ('a -> bool) -> 'a t -> 'a t
Filter elements out of the array. Only the elements satisfying the given predicate will be kept.
val filter_map : ('a -> 'b option ) -> 'a t -> 'b t
Map each element into another value, or discard it
val flat_map : ('a -> 'b t ) -> 'a t -> 'b array
Transform each element into an array, then flatten
val (>>=) : 'a t -> ('a -> 'b t ) -> 'b t
val (>>|) : 'a t -> ('a -> 'b ) -> 'b t
val (>|=) : 'a t -> ('a -> 'b ) -> 'b t
val except_idx : 'a t -> int -> 'a list
Remove given index, obtaining the list of the other elements
val (--) : int -> int -> int t
val (--^) : int -> int -> int t
Range array, excluding right bound
SlicesA slice is a part of an array, that requires no copying and shares its storage with the original array.
All indexing in a slice is relative to the beginning of a slice, not to the underlying array (meaning a slice is effectively like a regular array)
Generic Functionsval sort_generic :
(module MONO_ARRAY with type elt = 'elt and type t = 'arr ) ->
?cmp :('elt -> 'elt -> int) ->
'arr ->
unit
Sort the array, without allocating (eats stack space though). Performance might be lower than Array.sort
.