module BatArray:sig..end
The OCaml standard library provides a module of array functions. This BatArray module can be used to override the Array module or as a standalone module. It provides many additional functions.
This module extends Stdlib's Array module, go there for documentation on the rest of the functions and types.
A variant of arrays, arrays with capabilities, is provided in
module BatArray.Cap. This notion of capabilities permit the
transformation of a mutable array into a read-only or a write-only
arrays, without loss of speed and with the possibility of
distributing different capabilities to different expressions.
Author(s): Xavier Leroy, Richard W.M. Jones, David Teller
Arrays are mutable data structures with a fixed size, which
support fast access and modification, and are used pervasively in
imperative computing. While arrays are completely supported in
OCaml, it is often a good idea to investigate persistent
alternatives, such as lists or hash maps.
type'at ='a array
include BatEnum.Enumerable
include BatInterfaces.Mappable
val modify : ('a -> 'a) -> 'a array -> unitmodify f a replaces every element x of a with f x.val modifyi : (int -> 'a -> 'a) -> 'a array -> unitBatArray.modify, but the function is applied to the index of
the element as the first argument, and the element itself as
the second argument.val fold_lefti : ('a -> int -> 'b -> 'a) -> 'a -> 'b array -> 'afold_left, but with a counterval reduce : ('a -> 'a -> 'a) -> 'a array -> 'aArray.reduce f a is fold_left f a.(0) [|a.(1); ..; a.(n-1)|]. This
is useful for merging a group of things that have no
reasonable default value to return if the group is empty.Invalid_argument on empty arrays.val max : 'a array -> 'amax a returns the largest value in a as judged by
Pervasives.compareInvalid_argument on empty inputval min : 'a array -> 'amin a returns the smallest value in a as judged by
Pervasives.compareInvalid_argument on empty inputval iter2 : ('a -> 'b -> unit) -> 'a array -> 'b array -> unitArray.iter2 f [|a0; a1; ...; an|] [|b0; b1; ...; bn|] performs
calls f a0 b0; f a1 b1; ...; f an bn in that order.Invalid_argument if the two arrays have different lengths.val iter2i : (int -> 'a -> 'b -> unit) -> 'a array -> 'b array -> unitArray.iter2i f [|a0; a1; ...; an|] [|b0; b1; ...; bn|] performs
calls f 0 a0 b0; f 1 a1 b1; ...; f n an bn in that order.Invalid_argument if the two arrays have different lengths.val for_all2 : ('a -> 'b -> bool) -> 'a array -> 'b array -> boolArray.for_all but on two arrays.Invalid_argument if the two arrays have different lengths.val exists2 : ('a -> 'b -> bool) -> 'a array -> 'b array -> boolArray.exists but on two arrays.Invalid_argument if the two arrays have different lengths.val map2 : ('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c arrayArray.map but on two arrays.Invalid_argument if the two arrays have different lengths.val for_all : ('a -> bool) -> 'a array -> boolfor_all p [|a0; a1; ...; an|] checks if all elements of the array
satisfy the predicate p. That is, it returns
(p a0) && (p a1) && ... && (p an).val exists : ('a -> bool) -> 'a array -> boolexists p [|a0; a1; ...; an|] checks if at least one element of
the array satisfies the predicate p. That is, it returns
(p a0) || (p a1) || ... || (p an).val find : ('a -> bool) -> 'a array -> 'afind p a returns the first element of array a
that satisfies the predicate p.Not_found if there is no value that satisfies p in the
array a.val mem : 'a -> 'a array -> boolmem m a is true if and only if m is equal to an element of a.val memq : 'a -> 'a array -> boolArray.mem but uses physical equality instead of
structural equality to compare array elements.val findi : ('a -> bool) -> 'a array -> intfindi p a returns the index of the first element of array a
that satisfies the predicate p.Not_found if there is no value that satisfies p in the
array a.val filter : ('a -> bool) -> 'a array -> 'a arrayfilter p a returns all the elements of the array a
that satisfy the predicate p. The order of the elements
in the input array is preserved.val filteri : (int -> 'a -> bool) -> 'a array -> 'a arrayfilter but with the index passed to the predicate.val filter_map : ('a -> 'b option) -> 'a array -> 'b arrayfilter_map f e returns an array consisting in all elements
x such that f y returns Some x , where y is an element
of e.val find_all : ('a -> bool) -> 'a array -> 'a arrayfind_all is another name for Array.filter.val partition : ('a -> bool) -> 'a array -> 'a array * 'a arraypartition p a returns a pair of arrays (a1, a2), where
a1 is the array of all the elements of a that
satisfy the predicate p, and a2 is the array of all the
elements of a that do not satisfy p.
The order of the elements in the input array is preserved.val rev : 'a array -> 'a arrayval rev_in_place : 'a array -> unitval enum : 'a array -> 'a BatEnum.tval of_enum : 'a BatEnum.t -> 'a arrayval backwards : 'a array -> 'a BatEnum.tval of_backwards : 'a BatEnum.t -> 'a arrayval make_compare : ('a -> 'a -> int) -> 'a array -> 'a array -> intmake_compare c generates the lexicographical order on arrays
induced by c.val decorate_stable_sort : ('a -> 'b) -> 'a array -> 'a arraydecorate_sort f a returns a sorted copy of a such that if f
x < f y then x is earlier in the result than y. This
function is useful when f is expensive, as it only computes f
x once for each element in the array. See
:[http://en.wikipedia.org/wiki/Schwartzian_transform]Schwartzian
Transform.val decorate_fast_sort : ('a -> 'b) -> 'a array -> 'a arrayArray.decorate_sort, but uses fast_sort internally.val range : 'a array -> int BatEnum.trange a returns an enumeration of all valid indexes into the given
array. For example, range [|2;4;6;8|] = 0--3.val insert : 'a array -> 'a -> int -> 'a arrayinsert xs x i returns a copy of xs except the value x is
inserted in position i (and all later indices are shifted to the
right).val print : ?first:string ->
?last:string ->
?sep:string ->
('a BatIO.output -> 'b -> unit) -> 'a BatIO.output -> 'b t -> unitval sprint : ?first:string ->
?last:string ->
?sep:string -> ('a BatIO.output -> 'b -> unit) -> 'b t -> stringBatIO.to_string.val t_printer : 'a BatValue_printer.t -> 'a t BatValue_printer.tval print : ?first:string ->
?last:string ->
?sep:string ->
('a BatIO.output -> 'b -> unit) -> 'a BatIO.output -> 'b t -> unitval sprint : ?first:string ->
?last:string ->
?sep:string -> ('a BatIO.output -> 'b -> unit) -> 'b t -> stringBatIO.to_string.Array with
functions behaving slightly differently but having the same
name. This is by design: the functions are meant to override the
corresponding functions of Array.module Exceptionless:sig..end
Array without exceptions.
module Labels:sig..end
Array with labels.
module Cap:sig..end