Array (base.Base.Array)

type !'a t = 'a array

val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int

val globalize : ('a -> 'a) -> 'a t -> 'a t

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 : 
  ?pos:int ->
  ?len:int ->
  'a t ->
  compare:('a -> 'key -> int) ->
  [ `First_equal_to
  | `First_greater_than_or_equal_to
  | `First_strictly_greater_than
  | `Last_equal_to
  | `Last_less_than_or_equal_to
  | `Last_strictly_less_than ] ->
  'key ->
  int option

val binary_search_segmented : 
  ?pos:int ->
  ?len:int ->
  'a t ->
  segment_of:('a -> [ `Left | `Right ]) ->
  [ `First_on_right | `Last_on_left ] ->
  int option

val of_list : 'a list -> 'a t

val of_array : 'a array -> 'a t

val append : 'a t -> 'a t -> 'a t

val map : 'a t -> f:('a -> 'b) -> 'b t

val filter : 'a t -> f:('a -> bool) -> 'a t

val filter_map : 'a t -> f:('a -> 'b option) -> 'b t

val concat_map : 'a t -> f:('a -> 'b t) -> 'b t

val partition_tf : 'a t -> f:('a -> bool) -> 'a t * 'a t

val partition_map : 'a t -> f:('a -> ('b, 'c) Base__.Either0.t) -> 'b t * 'c t

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:'acc -> f:('acc -> 'a -> 'acc) -> 'acc

val fold_result : 
  'a t ->
  init:'acc ->
  f:('acc -> 'a -> ('acc, 'e) result) ->
  ('acc, 'e) result

val fold_until : 
  'a t ->
  init:'acc ->
  f:('acc -> 'a -> ('acc, 'final) Base__Container_intf.Continue_or_stop.t) ->
  finish:('acc -> '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 foldi : 'a t -> init:'b -> f:(int -> 'b -> 'a -> 'b) -> 'b

val iteri : 'a t -> f:(int -> 'a -> unit) -> unit

val existsi : 'a t -> f:(int -> 'a -> bool) -> bool

val for_alli : 'a t -> f:(int -> 'a -> bool) -> bool

val counti : 'a t -> f:(int -> 'a -> bool) -> int

val findi : 'a t -> f:(int -> 'a -> bool) -> (int * 'a) option

val find_mapi : 'a t -> f:(int -> 'a -> 'b option) -> 'b option

val init : int -> f:(int -> 'a) -> 'a t

val mapi : 'a t -> f:(int -> 'a -> 'b) -> 'b t

val filteri : 'a t -> f:(int -> 'a -> bool) -> 'a t

val filter_mapi : 'a t -> f:(int -> 'a -> 'b option) -> 'b t

val concat_mapi : 'a t -> f:(int -> 'a -> 'b t) -> 'b t

val invariant : ('a -> unit) -> 'a t -> unit

val max_length : int

val length : 'a t -> 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_local : len:int -> 'a -> 'a t

val create_float_uninitialized : len:int -> float t

val make_matrix : dimx:int -> dimy:int -> 'a -> 'a t t

val copy_matrix : 'a t t -> 'a t 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 : 
  src:'a t ->
  src_pos:int ->
  dst:'a t ->
  dst_pos:int ->
  len:int ->
  unit

val blito : 
  src:'a t ->
  ?src_pos:int ->
  ?src_len:int ->
  dst:'a t ->
  ?dst_pos:int ->
  unit ->
  unit

val unsafe_blit : 
  src:'a t ->
  src_pos:int ->
  dst:'a t ->
  dst_pos:int ->
  len:int ->
  unit

val sub : 'a t -> pos:int -> len:int -> 'a t

val subo : ?pos:int -> ?len:int -> 'a t -> 'a t

val folding_map : 'a t -> init:'acc -> f:('acc -> 'a -> 'acc * 'b) -> 'b t

val folding_mapi : 
  'a t ->
  init:'acc ->
  f:(int -> 'acc -> 'a -> 'acc * 'b) ->
  'b t

val fold_map : 'a t -> init:'acc -> f:('acc -> 'a -> 'acc * 'b) -> 'acc * 'b t

val fold_mapi : 
  'a t ->
  init:'acc ->
  f:(int -> 'acc -> 'a -> 'acc * 'b) ->
  'acc * 'b t

val fold_right : 'a t -> f:('a -> 'acc -> 'acc) -> init:'acc -> 'acc

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 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 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:'acc ->
  f:('acc -> 'a -> 'b -> 'acc) ->
  'acc

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 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_exn : 'a t -> f:(int -> 'a -> bool) -> int * 'a

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 : sig ... end