include module type of ArrayHoist an equality test for elements to arrays. Arrays are only equal if their lengths are the same and corresponding elements test equal.
val get : 'a t ‑> int ‑> 'aget a n returns the element number n of array a.
The first element has number 0.
The last element has number length a - 1.
You can also write a.(n) instead of get a n.
Raise Invalid_argument "index out of bounds"
if n is outside the range 0 to (length a - 1).
val 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 ‑> unitset a n x modifies array a in place, replacing
element number n with x.
You can also write a.(n) <- x instead of set a n x.
Raise Invalid_argument "index out of bounds"
if n is outside the range 0 to length a - 1.
val fold : ('a ‑> 'b ‑> 'a) ‑> 'a ‑> 'b t ‑> 'afold f x a computes f (... (f (f x a.(0)) a.(1)) ...) a.(n-1),
where n is the length of the array a.
val fold_while : ('a ‑> 'b ‑> 'a * [ `Stop | `Continue ]) ‑> 'a ‑> 'b t ‑> 'aFold left on array until a stop condition via ('a, `Stop) is
indicated by the accumulator.
fold_map f acc a is a fold_left-like function, but it also maps the
array to another array.
val iter : ('a ‑> unit) ‑> 'a t ‑> unititer f a applies function f in turn to all
the elements of a. It is equivalent to
f a.(0); f a.(1); ...; f a.(length a - 1); ().
val iteri : (int ‑> 'a ‑> unit) ‑> 'a t ‑> unitLike Array.iter, but the function is applied to the index of the element as first argument, and the element itself as second argument.
blit v1 o1 v2 o2 len copies len elements
from array v1, starting at element number o1, to array v2,
starting at element number o2. It works correctly even if
v1 and v2 are the same array, and the source and
destination chunks overlap.
Raise Invalid_argument "Array.blit" if o1 and len do not
designate a valid subarray of v1, or if o2 and len do not
designate a valid subarray of v2.
val sorted : ('a ‑> 'a ‑> int) ‑> 'a t ‑> 'a arraysorted cmp a makes a copy of a and sorts it with cmp.
val sort_indices : ('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 at which the i-th element of sorted cmp a
appears in a. a is not modified.
In other words, map (fun i -> a.(i)) (sort_indices cmp a) = sorted cmp a.
sort_indices yields the inverse permutation of sort_ranking.
val sort_ranking : ('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 index at which the i-the element of a appears
in sorted cmp a. a is not modified.
In other words, map (fun i -> (sorted cmp a).(i)) (sort_ranking cmp a) = a.
sort_ranking yields the inverse permutation of sort_indices.
In the absence of duplicate elements in a, we also have
lookup_exn a.(i) (sorted a) = (sorted_ranking a).(i).
val find_map : ('a ‑> 'b option) ‑> 'a t ‑> 'b optionfind_map f a returns Some y if there is an element x such
that f x = Some y, else it returns None.
val find_map_i : (int ‑> 'a ‑> 'b option) ‑> 'a t ‑> 'b optionLike find_map, but also pass the index to the predicate function.
val findi : (int ‑> 'a ‑> 'b option) ‑> 'a t ‑> 'b optionAlias to find_map_i.
val find_idx : ('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.
Undefined behavior if the array is not sorted wrt cmp.
Complexity: O(log (n)) (dichotomic search).
None if the key is not present, or
Some i (i the index of the key) otherwise.Like lookup, but
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
Raises Invalid_argument: ).
Complexity: O(log n) where n is the length of the array
(dichotomic search).
Returns
`At i if cmp arr.(i) x = 0 (for some i).`All_lower if all elements of arr are lower than x.`All_bigger if all elements of arr are bigger than x.`Just_after i if arr.(i) < x < arr.(i+1).`Empty if the array is empty.cmp.val for_all : ('a ‑> bool) ‑> 'a t ‑> boolfor_all p [|a1; ...; an|] checks if all elements of the array
satisfy the predicate p. That is, it returns
(p a1) && (p a2) && ... && (p an).
Forall on pairs of arrays.
val exists : ('a ‑> bool) ‑> 'a t ‑> boolexists p [|a1; ...; an|] checks if at least one element of
the array satisfies the predicate p. That is, it returns
(p a1) || (p a2) || ... || (p an).
Exists on pairs of arrays.
val random_choose : 'a t ‑> 'a random_genChoose an element randomly.
Return a sequence of the elements of an array.
The input array is shared with the sequence and modifications of it will result
in modification of the sequence.
map f a applies function f to all the elements of a,
and builds an array with the results returned by f:
[| f a.(0); f a.(1); ...; f a.(length a - 1) |].
map2 f a b applies function f to all the elements of a and b,
and builds an array with the results returned by f:
[| f a.(0) b.(0); ...; f a.(length a - 1) b.(length b - 1)|].
val except_idx : 'a t ‑> int ‑> 'a listRemove given index, obtaining the list of the other elements.
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.