type 'a klist = unit -> [ `Nil | `Cons of 'a * 'a klist ]type 'a random_gen = Random.State.t -> 'atype 'a printer = Format.formatter -> 'a -> unitval empty : 'a tval get : 'a t -> int -> 'aval get_safe : 'a t -> int -> 'a optionget_safe a i returns Some a.(i) if i is a valid index
val set : 'a t -> int -> 'a -> unitval length : _ t -> intval fold : f:('a -> 'b -> 'a) -> init:'a -> 'b t -> 'aval foldi : f:('a -> int -> 'b -> 'a) -> init:'a -> 'b t -> 'aFold left on array, with index
val fold_while :
f:('a -> 'b -> 'a * [ `Stop | `Continue ]) ->
init:'a ->
'b t ->
'aFold left on array until a stop condition via ('a, `Stop) is indicated by the accumulator
val iter : f:('a -> unit) -> 'a t -> unitval iteri : f:(int -> 'a -> unit) -> 'a t -> unitblit from i into j len copies len elements from the first array to the second. See Array.blit.
val reverse_in_place : 'a t -> unitReverse the array in place
val sorted : f:('a -> 'a -> int) -> 'a t -> 'a arraysorted cmp a makes a copy of a and sorts it with cmp.
val sort_indices : f:('a -> 'a -> int) -> 'a t -> int arraysort_indices cmp a returns a new array b, with the same length as a, such that b.(i) is the index of the i-th element of a in sort cmp a. In other words, map (fun i -> a.(i)) (sort_indices a) = sorted cmp a. a is not modified.
val sort_ranking : f:('a -> 'a -> int) -> 'a t -> int arraysort_ranking cmp a returns a new array b, with the same length as a, such that b.(i) is the position in sorted cmp a of the i-th element of a. a is not modified.
In other words, map (fun i -> (sorted cmp a).(i)) (sort_ranking cmp a) = a.
Without duplicates, we also have lookup_exn a.(i) (sorted a) = (sorted_ranking a).(i)
val find : f:('a -> 'b option) -> 'a t -> 'b optionfind f a returns Some y if there is an element x such that f x = Some y, else it returns None
val findi : f:(int -> 'a -> 'b option) -> 'a t -> 'b optionLike find, but also pass the index to the predicate function.
val find_idx : f:('a -> bool) -> 'a t -> (int * 'a) optionfind_idx p x returns Some (i,x) where x is the i-th element of l, and p x holds. Otherwise returns None
Lookup the index of some value in a sorted array.
Same as lookup_exn, but
val bsearch :
?cmp:('a -> 'a -> int) ->
key:'a ->
'a t ->
[ `All_lower | `All_bigger | `Just_after of int | `Empty | `At of int ]bsearch ?cmp key arr finds the index of the object key 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 : f:('a -> bool) -> 'a t -> boolval exists : f:('a -> bool) -> 'a t -> boolFold on two arrays stepwise.
val shuffle : 'a t -> unitShuffle randomly the array, in place
val shuffle_with : Random.State.t -> 'a t -> unitLike shuffle but using a specialized random state
val random_choose : 'a t -> 'a random_genChoose an element randomly.
Print an array, giving the printing function both index and item
Filter elements out of the array. Only the elements satisfying the given predicate will be kept.
Map each element into another value, or discard it
val except_idx : 'a t -> int -> 'a listRemove given index, obtaining the list of the other elements
val (--) : int -> int -> int tRange array
val (--^) : int -> int -> int tRange array, excluding right bound
val random : 'a random_gen -> 'a t random_genval random_non_empty : 'a random_gen -> 'a t random_genval random_len : int -> 'a random_gen -> 'a t random_genmodule type MONO_ARRAY = sig ... endval sort_generic :
(module MONO_ARRAY with type elt = 'elt and type t = 'arr) ->
?cmp:('elt -> 'elt -> int) ->
'arr ->
unitSort the array, without allocating (eats stack space though). Performance might be lower than Array.sort.