Array (hardcaml.hardcaml.ppx_hardcaml_runtime0.Ppx_hardcaml

include module type of struct include Core.Array end

The `Array` type

type 'a t = 'a Base.Array.t

include sig ... end

val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t

val bin_size_t : 'a. 'a Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer

val bin_size_t__local : 
  'a. 'a Bin_prot.Size.sizer__local ->
  'a t Bin_prot.Size.sizer__local

val bin_write_t : 'a. 'a Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer

val bin_write_t__local : 
  'a. 'a Bin_prot.Write.writer__local ->
  'a t Bin_prot.Write.writer__local

val bin_writer_t : 
  'a. 'a Bin_prot.Type_class.writer ->
  'a t Bin_prot.Type_class.writer

val bin_read_t : 'a. 'a Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader

val __bin_read_t__ : 
  'a. 'a Bin_prot.Read.reader ->
  'a t Bin_prot.Read.vtag_reader

val bin_reader_t : 
  'a. 'a Bin_prot.Type_class.reader ->
  'a t Bin_prot.Type_class.reader

val bin_t : 'a. 'a Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t

include sig ... end

val quickcheck_generator : 
  'a. 'a Ppx_quickcheck_runtime.Base_quickcheck.Generator.t ->
  'a t Ppx_quickcheck_runtime.Base_quickcheck.Generator.t @@ portable

val quickcheck_generator__portable : 
  'a. 'a Ppx_quickcheck_runtime.Base_quickcheck.Generator.t @ portable ->
  'a t Ppx_quickcheck_runtime.Base_quickcheck.Generator.t @ portable @@ portable

val quickcheck_observer : 
  'a. 'a Ppx_quickcheck_runtime.Base_quickcheck.Observer.t ->
  'a t Ppx_quickcheck_runtime.Base_quickcheck.Observer.t @@ portable

val quickcheck_observer__portable : 
  'a. 'a Ppx_quickcheck_runtime.Base_quickcheck.Observer.t @ portable ->
  'a t Ppx_quickcheck_runtime.Base_quickcheck.Observer.t @ portable @@ portable

val quickcheck_shrinker : 
  'a. 'a Ppx_quickcheck_runtime.Base_quickcheck.Shrinker.t ->
  'a t Ppx_quickcheck_runtime.Base_quickcheck.Shrinker.t @@ portable

val quickcheck_shrinker__portable : 
  'a. 'a Ppx_quickcheck_runtime.Base_quickcheck.Shrinker.t @ portable ->
  'a t Ppx_quickcheck_runtime.Base_quickcheck.Shrinker.t @ portable @@ portable

include Typerep_lib.Typerepable.S1 with type 'a t := 'a t

val typerep_of_t : 
  'a Typerep_lib.Std_internal.Typerep.t ->
  'a t Typerep_lib.Std_internal.Typerep.t @@ portable

val typename_of_t : 
  'a Typerep_lib.Typename.t ->
  'a t Typerep_lib.Typename.t @@ portable

The signature included from `Base.Array`

include Base.Binary_searchable.S1 with type 'a t := 'a t

See Binary_search.binary_search in binary_search.ml

val binary_search : 
  ?pos:int ->
  ?len:int ->
  'a t ->
  compare:('a -> ('key -> int) @ local) @ local ->
  ([ `Last_strictly_less_than
   | `Last_less_than_or_equal_to
   | `Last_equal_to
   | `First_equal_to
   | `First_greater_than_or_equal_to
   | `First_strictly_greater_than ] ->
  ('key ->
  int option @ local) @ local) @ local

See Binary_search.binary_search_segmented in binary_search.ml

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

val array_should_be_polymorphic_over_value_or_null : unit

Refer to this in code that hacks around array's current lack of value_or_null support. When the appropriate compiler features land, we will remove this binding and fix up relevant client code.

include Base.Indexed_container.S1_with_creators__''base_with_ext''
  with type 'a t := 'a t
  with type 'a t__bits64 = 'a t
   and type 'a t__bits32 = 'a t
   and type 'a t__word = 'a t
   and type 'a t__float64 = 'a t
   and type 'a t__float32 = 'a t
   and type 'a t__'value_mod_external64' = 'a t

include Base.Container.S1__''base_with_ext''
  with type 'a t := 'a t
  with type 'a t__bits64 = 'a t
  with type 'a t__bits32 = 'a t
  with type 'a t__word = 'a t
  with type 'a t__float64 = 'a t
  with type 'a t__float32 = 'a t
  with type 'a t__'value_mod_external64' = 'a t

type 'a t__bits64 = 'a t

and 'a t__bits32 = 'a t

and 'a t__word = 'a t

and 'a t__float64 = 'a t

and 'a t__float32 = 'a t

and 'a t__'value_mod_external64' = 'a t

include sig ... end

include Base.Container.Generic_types__''base_with_ext''
  with type (('a : bits64), _, _) t__bits64 := 'a t__bits64
  with type ('a : bits64) elt__bits64 := 'a
  with type (('a : bits32), _, _) t__bits32 := 'a t__bits32
  with type ('a : bits32) elt__bits32 := 'a
  with type (('a : word), _, _) t__word := 'a t__word
  with type ('a : word) elt__word := 'a
  with type (('a : float64), _, _) t__float64 := 'a t__float64
  with type ('a : float64) elt__float64 := 'a
  with type (('a : float32), _, _) t__float32 := 'a t__float32
  with type ('a : float32) elt__float32 := 'a
  with type ('a, _, _) t := 'a t
  with type 'a elt := 'a
  with type ('a, _, _) t__'value_mod_external64' :=
         'a t__'value_mod_external64'
  with type 'a elt__'value_mod_external64' := 'a

These are all like their equivalents in Container except that an index starting at 0 is added as the first argument to f.

include Base.Container.S1_with_creators__''base_with_ext''
  with type ('a : bits64) t__bits64 := 'a t__bits64
   and type ('a : bits32) t__bits32 := 'a t__bits32
   and type ('a : word) t__word := 'a t__word
   and type ('a : float64) t__float64 := 'a t__float64
   and type ('a : float32) t__float32 := 'a t__float32
   and type 'a t := 'a t
   and type 'a t__'value_mod_external64' := 'a t__'value_mod_external64'

include sig ... end

include Base.Container.Generic_types__''base_with_ext''
  with type (('a : bits64), _, _) t__bits64 := 'a t__bits64
  with type ('a : bits64) elt__bits64 := 'a
  with type (('a : bits32), _, _) t__bits32 := 'a t__bits32
  with type ('a : bits32) elt__bits32 := 'a
  with type (('a : word), _, _) t__word := 'a t__word
  with type ('a : word) elt__word := 'a
  with type (('a : float64), _, _) t__float64 := 'a t__float64
  with type ('a : float64) elt__float64 := 'a
  with type (('a : float32), _, _) t__float32 := 'a t__float32
  with type ('a : float32) elt__float32 := 'a
  with type ('a, _, _) t := 'a t
  with type 'a elt := 'a
  with type ('a, _, _) t__'value_mod_external64' :=
         'a t__'value_mod_external64'
  with type 'a elt__'value_mod_external64' := 'a

include sig ... end

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

val compare__local : 
  'a. ('a @ local -> ('a @ local -> int) @ local) ->
  'a t @ local ->
  ('a t @ local ->
  int) @ local

val equal : 'a. ('a -> 'a -> bool) -> 'a t -> 'a t -> bool

val equal__local : 
  'a. ('a @ local -> ('a @ local -> bool) @ local) ->
  'a t @ local ->
  ('a t @ local ->
  bool) @ local

val sexp_of_t : 'a. ('a -> Sexplib0.Sexp.t) -> 'a t -> Sexplib0.Sexp.t

val sexp_of_t__stack : 
  'a. ('a @ local -> Sexplib0.Sexp.t @ local) ->
  'a t @ local ->
  Sexplib0.Sexp.t @ local

val t_of_sexp : 'a. (Sexplib0.Sexp.t -> 'a) -> Sexplib0.Sexp.t -> 'a t

val globalize : 'a. ('a @ local -> 'a) -> 'a t @ local -> 'a t

include sig ... end

val t_sexp_grammar : 
  'a. 'a Sexplib0.Sexp_grammar.t ->
  'a t Sexplib0.Sexp_grammar.t @@ portable

include Base.Indexed_container.S1_with_creators with type 'a t := 'a t

include Base.Container.S1__''value'' with type 'a t := 'a t

include sig ... end

include Base.Container.Generic_types__''value''
  with type ('a, _, _) t := 'a t
  with type 'a elt := 'a

These are all like their equivalents in Container except that an index starting at 0 is added as the first argument to f.

val iteri : 'a 'p1 'p2. 'a t -> f:(int -> ('a -> unit) @ local) @ local -> unit

val existsi : 
  'a 'p1 'p2. 'a t ->
  f:(int -> ('a -> bool) @ local) @ local ->
  bool

val for_alli : 
  'a 'p1 'p2. 'a t ->
  f:(int -> ('a -> bool) @ local) @ local ->
  bool

val counti : 'a 'p1 'p2. 'a t -> f:(int -> ('a -> bool) @ local) @ local -> int

val foldi : 
  'a 'p1 'p2 'acc. 'a t ->
  init:'acc ->
  f:(int -> ('acc -> ('a -> 'acc) @ local) @ local) @ local ->
  'acc

val iteri_until : 
  'a 'p1 'p2 'final. 'a t ->
  f:
    (int -> ('a -> (unit, 'final) Base.Container.Continue_or_stop.t) @ local) @ local ->
  (finish:(int -> 'final) @ local ->
  'final) @ local

val find_mapi : 
  'a 'p1 'p2 'b. 'a t ->
  f:(int -> ('a -> 'b option) @ local) @ local ->
  'b option

val foldi_until : 
  'a 'p1 'p2 'acc 'final. 'a t ->
  init:'acc ->
  f:
    (int ->
      ('acc ->
      ('a ->
      ('acc, 'final) Base.Container.Continue_or_stop.t) @ local) @ local) @ local ->
  (finish:(int -> ('acc -> 'final) @ local) @ local ->
  'final) @ local

val findi : 
  'a 'p1 'p2. 'a t ->
  f:(int -> ('a -> bool) @ local) @ local ->
  (int * 'a) option

include Base.Container.S1_with_creators__''value'' with type 'a t := 'a t

include sig ... end

val is_empty : 'a 'p1 'p2. 'a t -> bool

val iter : 'a 'p1 'p2. 'a t -> f:('a -> unit) @ local -> unit

iter must allow exceptions raised in f to escape, terminating the iteration cleanly. The same holds for all functions below taking an f.

val exists : 'a 'p1 'p2. 'a t -> f:('a -> bool) @ local -> bool

Returns true if and only if there exists an element for which the provided function evaluates to true. This is a short-circuiting operation.

val for_all : 'a 'p1 'p2. 'a t -> f:('a -> bool) @ local -> bool

Returns true if and only if the provided function evaluates to true for all elements. This is a short-circuiting operation.

val count : 'a 'p1 'p2. 'a t -> f:('a -> bool) @ local -> int

Returns the number of elements for which the provided function evaluates to true.

val find : 'a 'p1 'p2. 'a t -> f:('a -> bool) @ local -> 'a Option.t

Returns as an option the first element for which f evaluates to true.

val to_list : 'a 'p1 'p2. 'a t -> 'a list

val min_elt : 
  'a 'p1 'p2. 'a t ->
  compare:('a -> ('a -> int) @ local) @ local ->
  'a Option.t

Returns a min (resp. max) element from the collection using the provided compare function. In case of a tie, the first element encountered while traversing the collection is returned. The implementation uses fold so it has the same complexity as fold. Returns None iff the collection is empty.

val max_elt : 
  'a 'p1 'p2. 'a t ->
  compare:('a -> ('a -> int) @ local) @ local ->
  'a Option.t

val sum : 
  'a 'sum 'p1 'p2. (module Base.Container.Summable with type t = 'sum) ->
  'a t ->
  f:('a -> 'sum) @ local ->
  'sum

Returns the sum of f i for all i in the container. The order in which the elements will be summed is unspecified.

val iter_until : 
  'a 'p1 'p2 'final. 'a t ->
  f:('a -> (unit, 'final) Base.Container.Continue_or_stop.t) @ local ->
  (finish:(unit -> 'final) @ local ->
  'final) @ local

iter_until t ~f ~finish is a short-circuiting version of iter. If f returns Stop x the computation ceases and returns x. If f always returns Continue () the final result is computed by finish.

val fold : 
  'a 'p1 'p2 'acc. 'a t ->
  init:'acc ->
  f:('acc -> ('a -> 'acc) @ local) @ local ->
  'acc

fold t ~init ~f returns f (... f (f (f init e1) e2) e3 ...) en, where e1..en are the elements of t.

val fold_result : 
  'a 'p1 'p2 'acc 'e. 'a t ->
  init:'acc ->
  f:('acc -> ('a -> ('acc, 'e) Result.t) @ local) @ local ->
  ('acc, 'e) Result.t

fold_result t ~init ~f is a short-circuiting version of fold that runs in the Result monad. If f returns an Error _, that value is returned without any additional invocations of f.

val find_map : 
  'a 'p1 'p2 'b. 'a t ->
  f:('a -> 'b Option.t) @ local ->
  'b Option.t

Returns the first evaluation of f that returns Some, and returns None if there is no such element.

val fold_until : 
  'a 'p1 'p2 'acc 'final. 'a t ->
  init:'acc ->
  f:
    ('acc -> ('a -> ('acc, 'final) Base.Container.Continue_or_stop.t) @ local) @ local ->
  (finish:('acc -> 'final) @ local ->
  'final) @ local

fold_until t ~init ~f ~finish is a short-circuiting version of fold. If f returns Stop _ the computation ceases and results in that value. If f returns Continue _, the fold will proceed. If f never returns Stop _, the final result is computed by finish.

Example:

  type maybe_negative =
    | Found_negative of int
    | All_nonnegative of { sum : int }

  (** [first_neg_or_sum list] returns the first negative number in [list], if any,
      otherwise returns the sum of the list. *)
  let first_neg_or_sum =
    List.fold_until ~init:0
      ~f:(fun sum x ->
        if x < 0
        then Stop (Found_negative x)
        else Continue (sum + x))
      ~finish:(fun sum -> All_nonnegative { sum })
  ;;

  let x = first_neg_or_sum [1; 2; 3; 4; 5]
  val x : maybe_negative = All_nonnegative {sum = 15}

  let y = first_neg_or_sum [1; 2; -3; 4; 5]
  val y : maybe_negative = Found_negative -3

val mem : 
  'a 'p1 'p2. 'a t ->
  'a ->
  equal:('a -> ('a -> bool) @ local) @ local ->
  bool

Checks whether the provided element is there, using equal.

include sig ... end

val of_list : 'a 'p1 'p2. 'a list -> 'a t

val append : 'a 'p1 'p2. 'a t -> 'a t -> 'a t

E.g., append (of_list [a; b]) (of_list [c; d; e]) is of_list [a; b; c; d; e]

val filter : 'a 'p1 'p2. 'a t -> f:('a -> bool) @ local -> 'a t

filter t ~f returns all the elements of t that satisfy the predicate f.

val partition_tf : 'a 'p1 'p2. 'a t -> f:('a -> bool) @ local -> 'a t * 'a t

partition_tf t ~f returns a pair t1, t2, where t1 is all elements of t that satisfy f, and t2 is all elements of t that do not satisfy f. The "tf" suffix is mnemonic to remind readers that the result is (trues, falses).

val filter_map : 'a 'p1 'p2 'b. 'a t -> f:('a -> 'b Option.t) @ local -> 'b t

filter_map t ~f applies f to every x in t. The result contains every y for which f x returns Some y.

val concat_map : 'a 'p1 'p2 'b. 'a t -> f:('a -> 'b t) @ local -> 'b t

concat_map t ~f is equivalent to concat (map t ~f).

val partition_map : 
  'a 'p1 'p2 'b 'c. 'a t ->
  f:('a -> ('b, 'c) Either.t) @ local ->
  'b t * 'c t

partition_map t ~f partitions t according to f.

val to_array : 'a. 'a t -> 'a array

val of_array : 'a. 'a array -> 'a t

include Base.Container.Generic_types__''value''
  with type ('a, _, _) t := 'a t
  with type 'a elt := 'a

val filteri : 
  'a 'p1 'p2. 'a t ->
  f:(int -> ('a -> bool) @ local) @ local ->
  'a t

val mapi : 'a 'p1 'p2 'b. 'a t -> f:(int -> ('a -> 'b) @ local) @ local -> 'b t

mapi is like map. Additionally, it passes in the index of each element as the first argument to the mapped function.

val filter_mapi : 
  'a 'p1 'p2 'b. 'a t ->
  f:(int -> ('a -> 'b option) @ local) @ local ->
  'b t

filter_mapi is like filter_map. Additionally, it passes in the index of each element as the first argument to the mapped function.

val concat_mapi : 
  'a 'p1 'p2 'b. 'a t ->
  f:(int -> ('a -> 'b t) @ local) @ local ->
  'b t

concat_mapi t ~f is like concat_map. Additionally, it passes the index as an argument.

val partition_mapi : 
  'a 'p1 'p2 'b 'c. 'a t ->
  f:(int -> ('a -> ('b, 'c) Base__.Either0.t) @ local) @ local ->
  'b t * 'c t

partition_mapi t ~f is like partition_map. Additionally, it passes the index as an argument.

include Base.Invariant.S1 with type 'a t := 'a t

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

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

val max_length : int

Maximum length of a normal array. The maximum length of a float array is max_length/2 on 32-bit machines and max_length on 64-bit machines.

val length : 'a. 'a array @ immutable -> int

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

Array.get a n returns the element number n of array a. The first element has number 0. The last element has number Array.length a - 1. You can also write a.(n) instead of Array.get a n.

Raise Invalid_argument "index out of bounds" if n is outside the range 0 to (Array.length a - 1).

val get_opt : 'a. 'a array @ local -> (int -> 'a option) @ local

Like get, but returns None instead of raising.

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

Array.set a n x modifies array a in place, replacing element number n with x. You can also write a.(n) <- x instead of Array.set a n x.

Raise Invalid_argument "index out of bounds" if n is outside the range 0 to Array.length a - 1.

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

Unsafe version of get. Can cause arbitrary behavior when used for an out-of-bounds array access.

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

Unsafe version of set. Can cause arbitrary behavior when used for an out-of-bounds array access.

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

create ~len x creates an array of length len with the value x populated in each element.

val create_local : 'a. len:int -> 'a -> 'a array @ local

create_local ~len x is like create. It allocates the array on the local stack. The array's elements are still global.

val magic_create_uninitialized : 'a. len:int -> 'a array

magic_create_uninitialized ~len creates an array of length len with uninitialized elements -- that is, they may contain arbitrary, nondeterministic 'a values. This can be significantly faster than using create.

magic_create_uninitialized can only be used for GC-ignorable arrays not involving tagged immediates and arrays of elements with unboxed number layout. The compiler rejects attempts to use magic_create_uninitialized to produce e.g. an ('a : value) array.

magic_create_uninitialized can break abstraction boundaries and type safety (e.g. by creating phony witnesses to type equality) and so should be used with caution.

val create_float_uninitialized : len:int -> float t

create_float_uninitialized ~len creates a float array of length len with uninitialized elements -- that is, they may contain arbitrary, nondeterministic float values. This can be significantly faster than using create, when unboxed float array representations are enabled.

val init : 'a. int -> f:(int -> 'a) @ local -> 'a array

init n ~f creates an array of length n with index i set to f i.

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

Array.make_matrix dimx dimy e returns a two-dimensional array (an array of arrays) with first dimension dimx and second dimension dimy. All the elements of this new matrix are initially physically equal to e. The element (x,y) of a matrix m is accessed with the notation m.(x).(y).

Raise Invalid_argument if dimx or dimy is negative or greater than Array.max_length.

If the value of e is a floating-point number, then the maximum size is only Array.max_length / 2.

val copy_matrix : 'a t t @ local -> 'a t t

Array.copy_matrix t returns a fresh copy of the array of arrays t. This is typically used when t is a matrix created by Array.make_matrix.

val concat : 'a. 'a t list @ local -> 'a t

Like Array.append, but concatenates a list of arrays.

val copy : 'a. 'a t @ local -> 'a t

Array.copy a returns a copy of a, that is, a fresh array containing the same elements as a.

val fill : 
  'a. 'a t @ local ->
  (pos:int ->
  (len:int ->
  ('a ->
  unit) @ local) @ local) @ local

Array.fill a ofs len x modifies the array a in place, storing x in elements number ofs to ofs + len - 1.

Raise Invalid_argument "Array.fill" if ofs and len do not designate a valid subarray of a.

Array.blit v1 o1 v2 o2 len copies len elements from array v1, starting at element number o1, to array v2, starting at element number o2. It works correctly even if v1 and v2 are the same array, and the source and destination chunks overlap.

Raise Invalid_argument "Array.blit" if o1 and len do not designate a valid subarray of v1, or if o2 and len do not designate a valid subarray of v2.

int_blit and float_blit provide fast bound-checked blits for immediate data types. The unsafe versions do not bound-check the arguments.

include Base.Blit.S1 with type 'a t := 'a t

val blit : 
  src:'a t @ local ->
  (src_pos:int ->
  (dst:'a t @ local ->
  (dst_pos:int ->
  (len:int ->
  unit) @ local) @ local) @ local) @ local

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

val unsafe_blit : 
  src:'a t @ local ->
  (src_pos:int ->
  (dst:'a t @ local ->
  (dst_pos:int ->
  (len:int ->
  unit) @ local) @ local) @ local) @ local

val sub : 'a t @ local -> (pos:int -> (len:int -> 'a t) @ local) @ local

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

val foldi_right : 
  'a t @ local ->
  (init:'acc ->
  (f:(int -> 'a -> 'acc -> 'acc) ->
  'acc) @ local) @ local

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

folding_map is a version of map that threads an accumulator through calls to f.

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

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

Array.fold_map is a combination of Array.fold and Array.map that threads an accumulator through calls to f.

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

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

Array.fold_right f a ~init computes f a.(0) (f a.(1) ( ... (f a.(n-1) init) ...)), where n is the length of the array a.

All sort functions in this module sort in increasing order by default.

val sort : 
  ?pos:int ->
  ?len:int ->
  'a t @ local ->
  (compare:('a -> ('a -> int) @ local) @ local ->
  unit) @ local

sort uses constant heap space. stable_sort uses linear heap space.

To sort only part of the array, specify pos to be the index to start sorting from and len indicating how many elements to sort.

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

val is_sorted : 
  'a t @ local ->
  (compare:('a -> ('a -> int) @ local) @ local ->
  bool) @ local

val is_sorted_strictly : 
  'a t @ local ->
  (compare:('a -> ('a -> int) @ local) @ local ->
  bool) @ local

is_sorted_strictly xs ~compare iff is_sorted xs ~compare and no two consecutive elements in xs are equal according to compare.

val merge : 'a t -> 'a t -> compare:('a -> ('a -> int) @ local) @ local -> 'a t

Merges two arrays: assuming that a1 and a2 are sorted according to the comparison function compare, merge a1 a2 ~compare will return a sorted array containing all the elements of a1 and a2. If several elements compare equal, the elements of a1 will be before the elements of a2.

val partitioni_tf : 
  'a t ->
  f:(int -> ('a -> bool) @ local) @ local ->
  'a t * 'a t

val cartesian_product : 'a t -> 'b t -> ('a * 'b) t

val transpose : 'a t t -> 'a t t option

transpose in the sense of a matrix transpose. It returns None if the arrays are not all the same length.

val transpose_exn : 'a t t -> 'a t t

val filter_opt : 'a option t -> 'a t

filter_opt array returns a new array where None entries are omitted and Some x entries are replaced with x. Note that this changes the index at which elements will appear.

Functions with the 2 suffix raise an exception if the lengths of the two given arrays aren't the same.

val iter2_exn : 'a t -> 'b t -> f:('a -> ('b -> unit) @ local) @ local -> unit

val map2_exn : 'a t -> 'b t -> f:('a -> ('b -> 'c) @ local) @ local -> 'c t

val fold2_exn : 
  'a t ->
  'b t ->
  init:'acc ->
  f:('acc -> ('a -> ('b -> 'acc) @ local) @ local) @ local ->
  'acc

val map_inplace : 'a t @ local -> (f:('a -> 'a) @ local -> unit) @ local

Modifies an array in place, applying f to every element of the array

val find_exn : 'a. 'a t -> f:('a -> bool) @ local -> 'a

find_exn f t returns the first a in t for which f t.(i) is true. It raises Stdlib.Not_found or Not_found_s if there is no such a.

val swap : 'a. 'a t @ local -> (int -> (int -> unit) @ local) @ local

swap arr i j swaps the value at index i with that at index j.

val rev_inplace : 'a. 'a t @ local -> unit

rev_inplace t reverses t in place.

val rev : 'a. 'a t -> 'a t

rev t returns a reversed copy of t

val of_list_rev : 'a. 'a list -> 'a t

of_list_rev l converts from list then reverses in place.

val find_map_exn : 'a 'b. 'a t -> f:('a -> 'b option) @ local -> 'b

Returns the first evaluation of f that returns Some. Raises Stdlib.Not_found or Not_found_s if f always returns None.

val find_mapi_exn : 
  'a 'b. 'a t ->
  f:(int -> ('a -> 'b option) @ local) @ local ->
  'b

find_mapi_exn is like find_map_exn but passes the index as an argument.

val of_list_map : 'a 'b. 'a list -> f:('a -> 'b) @ local -> 'b t

of_list_map l ~f is the same as of_list (List.map l ~f).

val of_list_mapi : 
  'a 'b. 'a list ->
  f:(int -> ('a -> 'b) @ local) @ local ->
  'b t

of_list_mapi l ~f is the same as of_list (List.mapi l ~f).

val of_list_rev_map : 'a 'b. 'a list -> f:('a -> 'b) @ local -> 'b t

of_list_rev_map l ~f is the same as of_list (List.rev_map l ~f).

val of_list_rev_mapi : 
  'a 'b. 'a list ->
  f:(int -> ('a -> 'b) @ local) @ local ->
  'b t

of_list_rev_mapi l ~f is the same as of_list (List.rev_mapi l ~f).

val for_all2_exn : 
  'a 'b. 'a t ->
  'b t ->
  f:('a -> ('b -> bool) @ local) @ local ->
  bool

for_all2_exn t1 t2 ~f fails if length t1 <> length t2.

val exists2_exn : 
  'a 'b. 'a t ->
  'b t ->
  f:('a -> ('b -> bool) @ local) @ local ->
  bool

exists2_exn t1 t2 ~f fails if length t1 <> length t2.

val findi_exn : 'a t -> f:(int -> ('a -> bool) @ local) @ local -> int * 'a

For backwards compatibility, we return a boxed product for the value-only version of findi_exn (instead of a value & value product)

val find_consecutive_duplicate : 
  'a t ->
  equal:('a -> ('a -> bool) @ local) @ local ->
  ('a * 'a) option

find_consecutive_duplicate t ~equal returns the first pair of consecutive elements (a1, a2) in t such that equal a1 a2. They are returned in the same order as they appear in t.

val reduce : 'a t -> f:('a -> ('a -> 'a) @ local) @ local -> 'a option

reduce f [a1; ...; an] is Some (f (... (f (f a1 a2) a3) ...) an). Returns None on the empty array.

val reduce_exn : 'a t -> f:('a -> ('a -> 'a) @ local) @ local -> 'a

val permute : 
  ?random_state:Base.Random.State.t ->
  ?pos:int ->
  ?len:int ->
  'a t @ local ->
  unit

permute ?random_state ?pos ?len t randomly permutes t in place.

To permute only part of the array, specify pos to be the index to start permuting from and len indicating how many elements to permute.

permute side-effects random_state by repeated calls to Random.State.int. If random_state is not supplied, permute uses Random.State.default.

val random_element : ?random_state:Base.Random.State.t -> 'a t -> 'a option

random_element ?random_state t is None if t is empty, else it is Some x for some x chosen uniformly at random from t.

random_element side-effects random_state by calling Random.State.int. If random_state is not supplied, random_element uses Random.State.default.

val random_element_exn : ?random_state:Base.Random.State.t -> 'a t -> 'a

val split_n : 'a t -> int -> 'a t * 'a t

split_n t n returns a pair of arrays (first, second) where first contains the first n elements of t and second contains the remaining elements.

If n >= length t, returns (t, [||]).
If n <= 0, returns ([||], t).

val chunks_of : 'a t -> length:int -> 'a t t

chunks_of t ~length returns an array of arrays whose concatenation is equal to the original array. Every array has length elements, except for possibly the last array, which may have fewer. chunks_of raises if length <= 0.

val zip : 'a t -> 'b t -> ('a * 'b) t option

zip is like List.zip, but for arrays.

val zip_exn : 'a t -> 'b t -> ('a * 'b) t

val unzip : ('a * 'b) t -> 'a t * 'b t

unzip is like List.unzip, but for arrays.

val sorted_copy : 
  'a t @ local ->
  (compare:('a -> ('a -> int) @ local) @ local ->
  'a t) @ local

sorted_copy ar compare returns a shallow copy of ar that is sorted. Similar to List.sort

val last : 'a t -> 'a

deprecated [since 2024-07] This was renamed to [last_exn]

val last_exn : 'a t -> 'a

val to_sequence : 'a t -> 'a Base.Sequence.t

The input array is copied internally so that future modifications of it do not change the sequence.

val to_sequence_mutable : 'a t -> 'a Base.Sequence.t

The input array is shared with the sequence and modifications of it will result in modification of the sequence.

Extensions

We add extensions for Int and Float arrays to make them bin-able, comparable, sexpable, and blit-able (via Blit.S). Permissioned provides fine-grained access control for arrays.

Operations supporting "normalized" indexes are also available.

module Int = Core.Array.Int

module Float = Core.Array.Float

val normalize : 'a t -> Base.Int.t -> Base.Int.t @@ portable

normalize array index returns a new index into the array such that if the index is less than zero, the returned index will "wrap around" -- i.e., array.(normalize array (-1)) returns the last element of the array.

val slice : 'a t -> Base.Int.t -> Base.Int.t -> 'a t @@ portable

slice t start stop returns a new array including elements t.(start) through t.(stop-1), normalized Python-style with the exception that stop = 0 is treated as stop = length t.

val nget : 'a t -> Base.Int.t -> 'a @@ portable

Array access with normalized index.

val nset : 'a t -> Base.Int.t -> 'a -> Base.Unit.t @@ portable

Array modification with normalized index.

module Permissioned = Core.Array.Permissioned

The Permissioned module gives the ability to restrict permissions on an array, so you can give a function read-only access to an array, create an immutable array, etc.

val for_ : int -> f:(int -> unit) -> unit

The Array type

The signature included from Base.Array

Extensions

The `Array` type

The signature included from `Base.Array`