# Module ExtArray.Array

    module Array: sig .. end

    val rev : 'a array -> 'a array

New functions

Array reversal.

    val rev_in_place : 'a array -> unit

In-place array reversal. The array argument is updated.

    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 map2 : ('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array

`Array.map2 f [|a1; ...; an|] [|b1; ...; bn|]` creates new array `[|f a1 b1; ...; f an bn|]`.

- Raises `Invalid_argument` if the length of `a1` does not equal the length of `a2`.

    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 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 `ExtArray.Array.mem` but uses physical equality instead of structural equality to compare array elements.

    val find : ('a -> bool) -> 'a array -> 'a

`find p a` returns the first element of array `a` that satisfies the predicate `p`. Raise `Not_found` if there is no value that satisfies `p` in the array `a`.

    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`. Raise `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 find_all : ('a -> bool) -> 'a array -> 'a array

`find_all` is another name for `ExtArray.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.

Enumerations

    val enum : 'a array -> 'a Enum.t

Returns an enumeration of the elements of an array.

    val of_enum : 'a Enum.t -> 'a array

Build an array from an enumeration.

Compatibility functions

These functions are reimplemented in extlib when they are missing from the stdlib

    val create_float : int -> float array

    val make_float : int -> float array

    module Floatarray: sig .. end

Old functions

These functions are already part of the Ocaml standard library and have not been modified. Please refer to the Ocaml Manual for documentation.

    val length : 'a array -> int

    val get : 'a array -> int -> 'a

    val set : 'a array -> int -> 'a -> unit

    val make : int -> 'a -> 'a array

    val create : int -> 'a -> 'a array

    val init : int -> (int -> 'a) -> 'a array

    val make_matrix : int -> int -> 'a -> 'a array array

    val create_matrix : int -> int -> 'a -> 'a array array

    val append : 'a array -> 'a array -> 'a array

    val concat : 'a array list -> 'a array

    val sub : 'a array -> int -> int -> 'a array

    val copy : 'a array -> 'a array

    val fill : 'a array -> int -> int -> 'a -> unit

    val blit : 'a array -> int -> 'a array -> int -> int -> unit

    val to_list : 'a array -> 'a list

    val of_list : 'a list -> 'a array

    val iter : ('a -> unit) -> 'a array -> unit

    val map : ('a -> 'b) -> 'a array -> 'b array

    val iteri : (int -> 'a -> unit) -> 'a array -> unit

    val mapi : (int -> 'a -> 'b) -> 'a array -> 'b array

    val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b array -> 'a

    val fold_right : ('b -> 'a -> 'a) -> 'b array -> 'a -> 'a

    val sort : ('a -> 'a -> int) -> 'a array -> unit

    val stable_sort : ('a -> 'a -> int) -> 'a array -> unit

    val fast_sort : ('a -> 'a -> int) -> 'a array -> unit

    val unsafe_get : 'a array -> int -> 'a

    val unsafe_set : 'a array -> int -> 'a -> unit

    val to_seq : 'a array -> 'a Stdlib.Seq.t

`*_seq` functions were introduced in OCaml 4.07.0, and are _not_ implemented in extlib for older OCaml versions

    val to_seqi : 'a array -> (int * 'a) Stdlib.Seq.t

    val of_seq : 'a Stdlib.Seq.t -> 'a array