Module Ppx_deriving_hardcaml_runtime.Array

include module type of struct include Base.Array end
type !'a t = 'a array
val compare : 'a Base__Ppx_compare_lib.compare -> 'a t Base__Ppx_compare_lib.compare
val t_of_sexp : ( Sexplib0__.Sexp.t -> 'a ) -> Sexplib0__.Sexp.t -> 'a t
val sexp_of_t : ( 'a -> Sexplib0__.Sexp.t ) -> 'a t -> Sexplib0__.Sexp.t
val t_sexp_grammar : 'a Sexplib0.Sexp_grammar.t -> 'a t Sexplib0.Sexp_grammar.t
val binary_search_segmented : ( 'a t, 'a ) Base__Binary_searchable_intf.binary_search_segmented
val mem : 'a t -> 'a -> equal:( 'a -> 'a -> bool ) -> bool
val is_empty : 'a t -> bool
val iter : 'a t -> f:( 'a -> unit ) -> unit
val fold : 'a t -> init:'accum -> f:( 'accum -> 'a -> 'accum ) -> 'accum
val fold_result : 'a t -> init:'accum -> f:( 'accum -> 'a -> ( 'accum, 'e ) Base__.Result.t ) -> ( 'accum, 'e ) Base__.Result.t
val fold_until : 'a t -> init:'accum -> f: ( 'accum -> 'a -> ( 'accum, 'final ) Base__Container_intf.Continue_or_stop.t ) -> finish:( 'accum -> 'final ) -> 'final
val exists : 'a t -> f:( 'a -> bool ) -> bool
val for_all : 'a t -> f:( 'a -> bool ) -> bool
val count : 'a t -> f:( 'a -> bool ) -> int
val sum : (module Base__Container_intf.Summable with type t = 'sum) -> 'a t -> f:( 'a -> 'sum ) -> 'sum
val find : 'a t -> f:( 'a -> bool ) -> 'a option
val find_map : 'a t -> f:( 'a -> 'b option ) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> compare:( 'a -> 'a -> int ) -> 'a option
val max_elt : 'a t -> compare:( 'a -> 'a -> int ) -> 'a option
val invariant : 'a Base__Invariant_intf.inv -> 'a t Base__Invariant_intf.inv
val max_length : int
val length : 'a array -> int
val get : 'a t -> int -> 'a
val set : 'a t -> int -> 'a -> unit
val unsafe_get : 'a t -> int -> 'a
val unsafe_set : 'a t -> int -> 'a -> unit
val create : len:int -> 'a -> 'a t
val create_float_uninitialized : len:int -> float t
val init : int -> f:( int -> 'a ) -> 'a t
val make_matrix : dimx:int -> dimy:int -> 'a -> 'a t t
val copy_matrix : 'a t t -> 'a t t
val append : 'a t -> 'a t -> 'a t
val concat : 'a t list -> 'a t
val copy : 'a t -> 'a t
val fill : 'a t -> pos:int -> len:int -> 'a -> unit
val blit : ( 'a t, 'a t ) Base__Blit_intf.blit
val blito : ( 'a t, 'a t ) Base__Blit_intf.blito
val unsafe_blit : ( 'a t, 'a t ) Base__Blit_intf.blit
val sub : ( 'a t, 'a t ) Base__Blit_intf.sub
val subo : ( 'a t, 'a t ) Base__Blit_intf.subo
val of_list : 'a list -> 'a t
val map : 'a t -> f:( 'a -> 'b ) -> 'b t
val folding_map : 'a t -> init:'b -> f:( 'b -> 'a -> 'b * 'c ) -> 'c t
val folding_mapi : 'a t -> init:'b -> f:( int -> 'b -> 'a -> 'b * 'c ) -> 'c t
val fold_map : 'a t -> init:'b -> f:( 'b -> 'a -> 'b * 'c ) -> 'b * 'c t
val fold_mapi : 'a t -> init:'b -> f:( int -> 'b -> 'a -> 'b * 'c ) -> 'b * 'c t
val iteri : 'a t -> f:( int -> 'a -> unit ) -> unit
val mapi : 'a t -> f:( int -> 'a -> 'b ) -> 'b t
val foldi : 'a t -> init:'b -> f:( int -> 'b -> 'a -> 'b ) -> 'b
val fold_right : 'a t -> f:( 'a -> 'b -> 'b ) -> init:'b -> 'b
val sort : ?pos:int -> ?len:int -> 'a t -> compare:( 'a -> 'a -> int ) -> unit
val stable_sort : 'a t -> compare:( 'a -> 'a -> int ) -> unit
val is_sorted : 'a t -> compare:( 'a -> 'a -> int ) -> bool
val is_sorted_strictly : 'a t -> compare:( 'a -> 'a -> int ) -> bool
val merge : 'a t -> 'a t -> compare:( 'a -> 'a -> int ) -> 'a t
val concat_map : 'a t -> f:( 'a -> 'b array ) -> 'b array
val concat_mapi : 'a t -> f:( int -> 'a -> 'b array ) -> 'b array
val partition_tf : 'a t -> f:( 'a -> bool ) -> 'a t * 'a t
val partitioni_tf : 'a t -> f:( int -> 'a -> bool ) -> 'a t * 'a t
val cartesian_product : 'a t -> 'b t -> ('a * 'b) t
val transpose : 'a t t -> 'a t t option
val transpose_exn : 'a t t -> 'a t t
val filter_opt : 'a option t -> 'a t
val filter_map : 'a t -> f:( 'a -> 'b option ) -> 'b t
val filter_mapi : 'a t -> f:( int -> 'a -> 'b option ) -> 'b t
val for_alli : 'a t -> f:( int -> 'a -> bool ) -> bool
val existsi : 'a t -> f:( int -> 'a -> bool ) -> bool
val counti : 'a t -> f:( int -> 'a -> bool ) -> int
val iter2_exn : 'a t -> 'b t -> f:( 'a -> 'b -> unit ) -> unit
val map2_exn : 'a t -> 'b t -> f:( 'a -> 'b -> 'c ) -> 'c t
val fold2_exn : 'a t -> 'b t -> init:'c -> f:( 'c -> 'a -> 'b -> 'c ) -> 'c
val for_all2_exn : 'a t -> 'b t -> f:( 'a -> 'b -> bool ) -> bool
val exists2_exn : 'a t -> 'b t -> f:( 'a -> 'b -> bool ) -> bool
val filter : 'a t -> f:( 'a -> bool ) -> 'a t
val filteri : 'a t -> f:( int -> 'a -> bool ) -> 'a t
val swap : 'a t -> int -> int -> unit
val rev_inplace : 'a t -> unit
val rev : 'a t -> 'a t
val of_list_rev : 'a list -> 'a t
val of_list_map : 'a list -> f:( 'a -> 'b ) -> 'b t
val of_list_mapi : 'a list -> f:( int -> 'a -> 'b ) -> 'b t
val of_list_rev_map : 'a list -> f:( 'a -> 'b ) -> 'b t
val of_list_rev_mapi : 'a list -> f:( int -> 'a -> 'b ) -> 'b t
val map_inplace : 'a t -> f:( 'a -> 'a ) -> unit
val find_exn : 'a t -> f:( 'a -> bool ) -> 'a
val find_map_exn : 'a t -> f:( 'a -> 'b option ) -> 'b
val findi : 'a t -> f:( int -> 'a -> bool ) -> (int * 'a) option
val findi_exn : 'a t -> f:( int -> 'a -> bool ) -> int * 'a
val find_mapi : 'a t -> f:( int -> 'a -> 'b option ) -> 'b option
val find_mapi_exn : 'a t -> f:( int -> 'a -> 'b option ) -> 'b
val find_consecutive_duplicate : 'a t -> equal:( 'a -> 'a -> bool ) -> ('a * 'a) option
val reduce : 'a t -> f:( 'a -> 'a -> 'a ) -> 'a option
val reduce_exn : 'a t -> f:( 'a -> 'a -> 'a ) -> 'a
val permute : ?random_state:Base__.Random.State.t -> ?pos:int -> ?len:int -> 'a t -> unit
val random_element : ?random_state:Base__.Random.State.t -> 'a t -> 'a option
val random_element_exn : ?random_state:Base__.Random.State.t -> 'a t -> 'a
val zip : 'a t -> 'b t -> ('a * 'b) t option
val zip_exn : 'a t -> 'b t -> ('a * 'b) t
val unzip : ('a * 'b) t -> 'a t * 'b t
val sorted_copy : 'a t -> compare:( 'a -> 'a -> int ) -> 'a t
val last : 'a t -> 'a
val equal : ( 'a -> 'a -> bool ) -> 'a t -> 'a t -> bool
val to_sequence : 'a t -> 'a Base__.Sequence.t
val to_sequence_mutable : 'a t -> 'a Base__.Sequence.t
module Private = Base__Array.Private
val for_ : Base__Int.t -> f:( int -> unit ) -> unit