Something went wrong. Try again.
forked from coq/coq
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195(************************************************************************)(* * The Rocq Prover / The Rocq Development Team *)(* v * Copyright INRIA, CNRS and contributors *)(* <O___,, * (see version control and CREDITS file for authors & dates) *)(* \VV/ **************************************************************)(* // * This file is distributed under the terms of the *)(* * GNU Lesser General Public License Version 2.1 *)(* * (see LICENSE file for the text of the license) *)(************************************************************************)
module type S = module type of Array
include Sval compare : ('a -> 'a -> int) -> 'a array -> 'a array -> int(** First size comparison, then lexicographic order. *)
val equal : ('a -> 'a -> bool) -> 'a array -> 'a array -> bool(** Lift equality to array type. *)
val equal_norefl : ('a -> 'a -> bool) -> 'a array -> 'a array -> bool(** Like {!equal} but does not assume that equality is reflexive: no optimisation is performed if both arrays are physically the same. *)
val is_empty : 'a array -> bool(** True whenever the array is empty. *)
val exists2 : ('a -> 'b -> bool) -> 'a array -> 'b array -> bool
val for_all2 : ('a -> 'b -> bool) -> 'a array -> 'b array -> boolval for_all3 : ('a -> 'b -> 'c -> bool) -> 'a array -> 'b array -> 'c array -> boolval for_all4 : ('a -> 'b -> 'c -> 'd -> bool) -> 'a array -> 'b array -> 'c array -> 'd array -> boolval for_all_i : (int -> 'a -> bool) -> int -> 'a array -> bool
val findi : (int -> 'a -> bool) -> 'a array -> int option
val find2_map : ('a -> 'b -> 'c option) -> 'a array -> 'b array -> 'c option(** First result which is not None, or None; [Failure "Array.find2_map"] if the arrays don't have the same length *)
val hd : 'a array -> 'a(** First element of an array, or [Failure "Array.hd"] if empty. *)
val tl : 'a array -> 'a array(** Remaining part of [hd], or [Failure "Array.tl"] if empty. *)
val last : 'a array -> 'a(** Last element of an array, or [Failure "Array.last"] if empty. *)
val cons : 'a -> 'a array -> 'a array(** Append an element on the left. *)
val rev : 'a array -> unit(** In place reversal. *)
val fold_right_i : (int -> 'b -> 'a -> 'a) -> 'b array -> 'a -> 'aval fold_left_i : (int -> 'a -> 'b -> 'a) -> 'a -> 'b array -> 'aval fold_right2 : ('a -> 'b -> 'c -> 'c) -> 'a array -> 'b array -> 'c -> 'cval fold_right3 : ('a -> 'b -> 'c -> 'd -> 'd) -> 'a array -> 'b array -> 'c array -> 'd -> 'dval fold_left2 : ('a -> 'b -> 'c -> 'a) -> 'a -> 'b array -> 'c array -> 'aval fold_left3 : ('a -> 'b -> 'c -> 'd -> 'a) -> 'a -> 'b array -> 'c array -> 'd array -> 'aval fold_left4 : ('a -> 'b -> 'c -> 'd -> 'e -> 'a) -> 'a -> 'b array -> 'c array -> 'd array -> 'e array -> 'aval fold_left2_i : (int -> 'a -> 'b -> 'c -> 'a) -> 'a -> 'b array -> 'c array -> 'aval fold_left3_i : (int -> 'a -> 'b -> 'c -> 'd -> 'a) -> 'a -> 'b array -> 'c array -> 'd array -> 'aval fold_left_from : int -> ('a -> 'b -> 'a) -> 'a -> 'b array -> 'a
val map_to_list : ('a -> 'b) -> 'a array -> 'b list(** Composition of [map] and [to_list]. *)
val map_of_list : ('a -> 'b) -> 'a list -> 'b array(** Composition of [map] and [of_list]. *)
val chop : int -> 'a array -> 'a array * 'a array(** [chop i a] returns [(a1, a2)] s.t. [a = a1 + a2] and [length a1 = n]. Raise [Failure "Array.chop"] if [i] is not a valid index. *)
val split : ('a * 'b) array -> 'a array * 'b arrayval split3 : ('a * 'b * 'c) array -> 'a array * 'b array * 'c arrayval split4 : ('a * 'b * 'c * 'd) array -> 'a array * 'b array * 'c array * 'd arrayval transpose : 'a array array -> 'a array array
val map2_i : (int -> 'a -> 'b -> 'c) -> 'a array -> 'b array -> 'c arrayval map3 : ('a -> 'b -> 'c -> 'd) -> 'a array -> 'b array -> 'c array -> 'd arrayval map3_i : (int -> 'a -> 'b -> 'c -> 'd) -> 'a array -> 'b array -> 'c array -> 'd array
val map_left : ('a -> 'b) -> 'a array -> 'b array(** As [map] but guaranteed to be left-to-right. *)
val iter2_i : (int -> 'a -> 'b -> unit) -> 'a array -> 'b array -> unit(** Iter on two arrays. Raise [Invalid_argument "Array.iter2_i"] if sizes differ. *)
val iter3 : ('a -> 'b -> 'c -> unit) -> 'a array -> 'b array -> 'c array -> unit(** Iter on three arrays. Raise [Invalid_argument "Array.iter3"] if sizes differ. *)
val fold_left_map : ('a -> 'b -> 'a * 'c) -> 'a -> 'b array -> 'a * 'c array(** [fold_left_map f e_0 [|l_1...l_n|] = e_n,[|k_1...k_n|]] where [(e_i,k_i)=f e_{i-1} l_i]; see also [Smart.fold_left_map] *)
val fold_right_map : ('a -> 'c -> 'b * 'c) -> 'a array -> 'c -> 'b array * 'c(** Same, folding on the right *)
val fold_left_map_i : (int -> 'a -> 'b -> 'a * 'c) -> 'a -> 'b array -> 'a * 'c array(** Same than [fold_left_map] but passing the index of the array *)
val fold_left2_map : ('a -> 'b -> 'c -> 'a * 'd) -> 'a -> 'b array -> 'c array -> 'a * 'd array(** Same with two arrays, folding on the left; see also [Smart.fold_left2_map] *)
val fold_left2_map_i : (int -> 'a -> 'b -> 'c -> 'a * 'd) -> 'a -> 'b array -> 'c array -> 'a * 'd array(** Same than [fold_left2_map] but passing the index of the array *)
val fold_right2_map : ('a -> 'b -> 'c -> 'd * 'c) -> 'a array -> 'b array -> 'c -> 'd array * 'c(** Same with two arrays, folding on the right *)
val distinct : 'a array -> bool(** Return [true] if every element of the array is unique (for default equality). *)
val rev_of_list : 'a list -> 'a array(** [rev_of_list l] is equivalent to [Array.of_list (List.rev l)]. *)
val rev_to_list : 'a array -> 'a list(** [rev_to_list a] is equivalent to [List.rev (List.of_array a)]. *)
val filter_with : bool list -> 'a array -> 'a array(** [filter_with b a] selects elements of [a] whose corresponding element in [b] is [true]. Raise [Invalid_argument _] when sizes differ. *)
module Smart :sig val map : ('a -> 'a) -> 'a array -> 'a array (** [Smart.map f a] behaves as [map f a] but returns [a] instead of a copy when [f x == x] for all [x] in [a]. *)
val map_i : (int -> 'a -> 'a) -> 'a array -> 'a array
val map2 : ('a -> 'b -> 'b) -> 'a array -> 'b array -> 'b array (** [Smart.map2 f a b] behaves as [map2 f a b] but returns [a] instead of a copy when [f x y == y] for all [x] in [a] and [y] in [b] pointwise. *)
val fold_left_map : ('a -> 'b -> 'a * 'b) -> 'a -> 'b array -> 'a * 'b array (** [Smart.fold_left_map f a b] behaves as [fold_left_map] but returns [b] as second component instead of a copy of [b] when the output array is pointwise the same as the input array [b] *)
val fold_left_map_i : (int -> 'a -> 'b -> 'a * 'b) -> 'a -> 'b array -> 'a * 'b array (** [Smart.fold_left_map_i f a b] behaves as [fold_left_map_i] but returns [b] as second component instead of a copy of [b] when the output array is pointwise the same as the input array [b] *)
val fold_left2_map : ('a -> 'b -> 'c -> 'a * 'c) -> 'a -> 'b array -> 'c array -> 'a * 'c array (** [Smart.fold_left2_map f a b c] behaves as [fold_left2_map] but returns [c] as second component instead of a copy of [c] when the output array is pointwise the same as the input array [c] *)
end(** The functions defined in this module are optimized specializations of the main ones, when the returned array is of same type as one of the original array. *)
module Fun1 :sig val map : ('r -> 'a -> 'b) -> 'r -> 'a array -> 'b array (** [Fun1.map f x v = map (f x) v] *)
val iter : ('r -> 'a -> unit) -> 'r -> 'a array -> unit (** [Fun1.iter f x v = iter (f x) v] *)
val iter2 : ('r -> 'a -> 'b -> unit) -> 'r -> 'a array -> 'b array -> unit (** [Fun1.iter2 f x v1 v2 = iter (f x) v1 v2] *)
module Smart : sig val map : ('r -> 'a -> 'a) -> 'r -> 'a array -> 'a array (** [Fun1.Smart.map f x v = Smart.map (f x) v] *) end
end(** The functions defined in this module are the same as the main ones, except that they are all higher-order, and their function arguments have an additional parameter. This allows us to prevent closure creation in critical cases. *)