Module NS.Array

include module type of ContainersLabels.Array
type !'a iter = ('a -> unit) -> unit
type !'a gen = unit -> 'a option
type !'a equal = 'a -> 'a -> bool
type !'a ord = 'a -> 'a -> int
type !'a random_gen = Stdlib.Random.State.t -> 'a
type !'a printer = Stdlib.Format.formatter -> 'a -> unit
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_float : int -> float array
val init : int -> f:(int -> 'a) -> 'a array
val make_matrix : dimx:int -> dimy:int -> 'a -> 'a array array
val init_matrix : dimx:int -> dimy:int -> f:(int -> int -> 'a) -> 'a array array
val append : 'a array -> 'a array -> 'a array
val concat : 'a array list -> 'a array
val copy : 'a array -> 'a array
val fill : 'a array -> pos:int -> len:int -> 'a -> unit
val blit : src:'a array -> src_pos:int -> dst:'a array -> dst_pos:int -> len:int -> unit
val to_list : 'a array -> 'a list
val of_list : 'a list -> 'a array
val fold_left : f:('acc -> 'a -> 'acc) -> init:'acc -> 'a array -> 'acc
val fold_left_map : f:('acc -> 'a -> 'acc * 'b) -> init:'acc -> 'a array -> 'acc * 'b array
val memq : 'a -> set:'a array -> bool
val find_opt : f:('a -> bool) -> 'a array -> 'a option
val find_index : f:('a -> bool) -> 'a array -> int option
val find_mapi : f:(int -> 'a -> 'b option) -> 'a array -> 'b option
val split : ('a * 'b) array -> 'a array * 'b array
val sort : cmp:('a -> 'a -> int) -> 'a array -> unit
val stable_sort : cmp:('a -> 'a -> int) -> 'a array -> unit
val fast_sort : cmp:('a -> 'a -> int) -> 'a array -> unit
val to_seqi : 'a array -> (int * 'a) Stdlib.Seq.t
val of_seq : 'a Stdlib.Seq.t -> 'a array
val unsafe_get : 'a array -> int -> 'a
val unsafe_set : 'a array -> int -> 'a -> unit
module Floatarray : sig ... end
val empty : 'a array
val swap : 'a array -> int -> int -> unit
val get_safe : 'a array -> int -> 'a option
val map_inplace : f:('a -> 'a) -> 'a array -> unit
val mapi_inplace : f:(int -> 'a -> 'a) -> 'a array -> unit
val foldi : f:('a -> int -> 'b -> 'a) -> init:'a -> 'b array -> 'a
val fold_while : f:('a -> 'b -> 'a * [ `Continue | `Stop ]) -> init:'a -> 'b array -> 'a
val scan_left : f:('acc -> 'a -> 'acc) -> init:'acc -> 'a array -> 'acc array
val reverse_in_place : 'a array -> unit
val sorted : f:('a -> 'a -> int) -> 'a array -> 'a array
val sort_indices : f:('a -> 'a -> int) -> 'a array -> int array
val sort_ranking : f:('a -> 'a -> int) -> 'a array -> int array
val find_map : f:('a -> 'b option) -> 'a array -> 'b option
val find_map_i : f:(int -> 'a -> 'b option) -> 'a array -> 'b option
val find_idx : f:('a -> bool) -> 'a array -> (int * 'a) option
val max : cmp:('a -> 'a -> int) -> 'a array -> 'a option
val max_exn : cmp:('a -> 'a -> int) -> 'a array -> 'a
val argmax : cmp:('a -> 'a -> int) -> 'a array -> int option
val argmax_exn : cmp:('a -> 'a -> int) -> 'a array -> int
val min : cmp:('a -> 'a -> int) -> 'a array -> 'a option
val min_exn : cmp:('a -> 'a -> int) -> 'a array -> 'a
val argmin : cmp:('a -> 'a -> int) -> 'a array -> int option
val argmin_exn : cmp:('a -> 'a -> int) -> 'a array -> int
val lookup : cmp:'a ord -> key:'a -> 'a array -> int option
val lookup_exn : cmp:'a ord -> key:'a -> 'a array -> int
val bsearch : cmp:('a -> 'a -> int) -> key:'a -> 'a array -> [ `All_bigger | `All_lower | `At of int | `Empty | `Just_after of int ]
val for_all2 : f:('a -> 'b -> bool) -> 'a array -> 'b array -> bool
val exists2 : f:('a -> 'b -> bool) -> 'a array -> 'b array -> bool
val fold2 : f:('acc -> 'a -> 'b -> 'acc) -> init:'acc -> 'a array -> 'b array -> 'acc
val iter2 : f:('a -> 'b -> unit) -> 'a array -> 'b array -> unit
val shuffle : 'a array -> unit
val shuffle_with : Stdlib.Random.State.t -> 'a array -> unit
val random_choose : 'a array -> 'a random_gen
val to_string : ?sep:string -> ('a -> string) -> 'a array -> string
val to_iter : 'a array -> 'a iter
val to_seq : 'a array -> 'a Stdlib.Seq.t
val to_gen : 'a array -> 'a gen
val pp_i : ?pp_start:unit printer -> ?pp_stop:unit printer -> ?pp_sep:unit printer -> (int -> 'a printer) -> 'a array printer
val map2 : f:('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array
val rev : 'a array -> 'a array
val filter : f:('a -> bool) -> 'a array -> 'a array
val filter_map : f:('a -> 'b option) -> 'a array -> 'b array
val monoid_product : f:('a -> 'b -> 'c) -> 'a array -> 'b array -> 'c array
val flat_map : f:('a -> 'b array) -> 'a array -> 'b array
val except_idx : 'a array -> int -> 'a list
val random : 'a random_gen -> 'a array random_gen
val random_non_empty : 'a random_gen -> 'a array random_gen
val random_len : int -> 'a random_gen -> 'a array random_gen
module type MONO_ARRAY = sig ... end
val sort_generic : (module MONO_ARRAY with type elt = 'elt and type t = 'arr) -> cmp:('elt -> 'elt -> int) -> 'arr -> unit
module Infix : sig ... end
val (>>=) : 'a array -> ('a -> 'b array) -> 'b array
val (>>|) : 'a array -> ('a -> 'b) -> 'b array
val (>|=) : 'a array -> ('a -> 'b) -> 'b array
val (--) : int -> int -> int array
val (--^) : int -> int -> int array
val let+ : 'a array -> ('a -> 'b) -> 'b array
val and+ : 'a array -> 'b array -> ('a * 'b) array
val let* : 'a array -> ('a -> 'b array) -> 'b array
val and* : 'a array -> 'b array -> ('a * 'b) array
type 'a t = 'a array
include Ppx_compare_lib.Comparable.S1 with type 'a t := 'a t
val compare : 'a Base__Ppx_compare_lib.compare -> 'a t Base__Ppx_compare_lib.compare
include Ppx_compare_lib.Equal.S1 with type 'a t := 'a t
val equal : 'a Base__Ppx_compare_lib.equal -> 'a t Base__Ppx_compare_lib.equal
include Sexplib0.Sexpable.S1 with type '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 sub : ?pos:int -> ?len:int -> 'a t -> 'a t

sub a ~pos ~len returns a fresh array of length len, containing the elements number pos to pos + len - 1 of array a. If omitted, pos defaults to the beginning of the array and len defaults to the rest of the array.

val of_ : 'a -> 'a t
val of_iter : 'a iter -> 'a t
val of_list_rev : 'a list -> 'a t
val of_list_map : 'a list -> f:('a -> 'b) -> 'b t
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(int -> 'a -> 'b) -> 'b t
val map_endo : 'a t -> f:('a -> 'a) -> 'a t

Like map, but specialized to require f to be an endofunction, which enables preserving == if f preserves == of every element.

val reduce_adjacent : 'a t -> f:('a -> 'a -> 'a option) -> 'a t
val combine : 'a t -> 'b t -> ('a * 'b) t
val is_empty : 'a t -> bool
val mem : 'a -> 'a t -> eq:('a -> 'a -> bool) -> bool
val contains_adjacent_duplicate : eq:('a -> 'a -> bool) -> 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val iter2_exn : 'a t -> 'b t -> f:('a -> 'b -> unit) -> unit
val iteri : 'a t -> f:(int -> 'a -> unit) -> unit
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val for_all2_exn : 'a t -> 'b t -> f:('a -> 'b -> bool) -> bool
val fold : 'a t -> 's -> f:('a -> 's -> 's) -> 's
val fold_right : 'a t -> 's -> f:('a -> 's -> 's) -> 's
val fold_map : 'a t -> 's -> f:('a -> 's -> 'b * 's) -> 'b t * 's
val fold_map_until : 'a t -> 's -> f:('a -> 's -> [ `Continue of 'b * 's | `Stop of 'c ]) -> finish:(('b t * 's) -> 'c) -> 'c
val fold2_exn : 'a t -> 'b t -> 's -> f:('a -> 'b -> 's -> 's) -> 's
val to_list_rev : 'a array -> 'a list
val to_list_rev_map : 'a array -> f:('a -> 'b) -> 'b list
val pp : (unit, Stdlib.Format.formatter, unit, unit) Stdlib.format4 -> (Stdlib.Format.formatter -> 'a -> unit) -> Stdlib.Format.formatter -> 'a array -> unit