Previous  Up  Next

Module BatArray


module BatArray: sig .. end
Additional and modified functions for arrays.

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 some additional functions.


Array operations.

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.

A variant of arrays, arrays with capabilities, is provided in module 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.

This module extends Stdlib's Array module, go there for documentation on the rest of the functions and types.

type 'a t = 'a array
The type of arrays.
include BatEnum.Enumerable
include BatInterfaces.Mappable

Base operations

val fold_lefti : ('a -> int -> 'b -> 'a) -> 'a -> 'b array -> 'a
As fold_left, but with a counter
val reduce : ('a -> 'a -> 'a) -> 'a array -> 'a
Array.reduce f a is fold_left f a.(0) a.(1 .. n-1).
Raises Invalid_argument on empty arrays.
val max : 'a array -> 'a
max a returns the largest value in a as judged by Pervasives.compare
val min : 'a array -> 'a
min a returns the smallest value in a as judged by Pervasives.compare

Operations on two arrays

val iter2 : ('a -> 'b -> unit) -> 'a array -> 'b array -> unit
Array.iter2 f [|a1; ...; an|] [|b1; ...; bn|] performs calls f a1 b1; ...; f an bn in that order.
Raises Invalid_argument if the length of a1 does not equal the length of a2.
val iter2i : (int -> 'a -> 'b -> unit) -> 'a array -> 'b array -> unit
Array.iter2i f [|a1; ...; an|] [|b1; ...; bn|] performs calls f 0 a1 b1; ...; f (n - 1) an bn in that order.
Raises Invalid_argument if the length of a1 does not equal the length of a2.
val for_all2 : ('a -> 'b -> bool) -> 'a array -> 'b array -> bool
As Array.for_all but on two arrays.
Raises Invalid_argument if the arrays aren't the same length.
val exists2 : ('a -> 'b -> bool) -> 'a array -> 'b array -> bool
As Array.exists but on two arrays.
Raises Invalid_argument if the arrays aren't the same length.
val map2 : ('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array
As Array.map but on two arrays.
Raises Invalid_argument if the arrays aren't the same length.

Predicates

val for_all : ('a -> bool) -> 'a array -> bool
for_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).
val exists : ('a -> bool) -> 'a array -> bool
exists 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).
val find : ('a -> bool) -> 'a array -> 'a
find p a returns the first element of array a that satisfies the predicate p.
Raises Not_found if there is no value that satisfies p in the array a.
val mem : 'a -> 'a array -> bool
mem m a is true if and only if m is equal to an element of a.
val memq : 'a -> 'a array -> bool
Same as Array.mem but uses physical equality instead of structural equality to compare array elements.
val findi : ('a -> bool) -> 'a array -> int
findi p a returns the index of the first element of array a that satisfies the predicate p.
Raises Not_found if there is no value that satisfies p in the array a.
val filter : ('a -> bool) -> 'a array -> 'a array
filter 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 filter_map : ('a -> 'b option) -> 'a array -> 'b array
filter_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 array
find_all is another name for Array.filter.
val partition : ('a -> bool) -> 'a array -> 'a array * 'a array
partition 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.

Array transformations

val rev : 'a array -> 'a array
Array reversal.
val rev_in_place : 'a array -> unit
In-place array reversal. The array argument is updated.

Conversions

val enum : 'a array -> 'a BatEnum.t
Returns an enumeration of the elements of an array. Behavior of the enumeration is undefined if the contents of the array changes afterwards.
val of_enum : 'a BatEnum.t -> 'a array
Build an array from an enumeration.
val backwards : 'a array -> 'a BatEnum.t
Returns an enumeration of the elements of an array, from last to first.
val of_backwards : 'a BatEnum.t -> 'a array
Build an array from an enumeration, going into reverse order.

Utilities

val make_compare : ('a -> 'a -> int) -> 'a array -> 'a array -> int
make_compare c generates the lexicographical order on arrays induced by c
val decorate_stable_sort : ('a -> 'b) -> 'a array -> 'a array
decorate_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 array
As Array.decorate_sort, but uses fast_sort internally
val range : 'a array -> int BatEnum.t
returns an enumeration of all valid indexes into the given array.

Boilerplate code


Printing

val print : ?first:string ->
       ?last:string ->
       ?sep:string ->
       ('a BatIO.output -> 'b -> unit) -> 'a BatIO.output -> 'b t -> unit
Print the contents of an array
val sprint : ?first:string ->
       ?last:string ->
       ?sep:string -> ('a BatIO.output -> 'b -> unit) -> 'b t -> string
Using a string printer, print an array to a string (as sprintf vs. printf)
val t_printer : 'a BatValue_printer.t -> 'a t BatValue_printer.t