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 make : 'a array -> int -> len:int -> 'a tCreate a slice from given offset and length..
val of_slice : ('a array * int * int) -> 'a tMake a sub-array from a triple (arr, i, len) where arr is the array, i the offset in arr, and len the number of elements of the slice.
val to_slice : 'a t -> 'a array * int * intConvert into a triple (arr, i, len) where len is the length of the subarray of arr starting at offset i
val to_list : 'a t -> 'a listConvert directly to a list
val full : 'a array -> 'a tSlice that covers the full array
val underlying : 'a t -> 'a arrayUnderlying array (shared). Modifying this array will modify the slice
val copy : 'a t -> 'a arrayCopy into a new array
val set : 'a t -> int -> 'a -> unitval length : _ t -> intval fold : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'aval foldi : ('a -> int -> 'b -> 'a) -> 'a -> 'b t -> 'aFold left on array, with index
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
val iter : ('a -> unit) -> 'a t -> unitval iteri : (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 : ('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 : ('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 : (int -> 'a -> 'b option) -> 'a t -> 'b optionLike find, but also pass the index to the predicate function.
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.
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 -> boolval exists : ('a -> bool) -> 'a t -> boolval 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.