Module Incremental_kernel__Import.Array

include Core_kernel.Array

This module extends Base.Array.

The Array type

type 'a t = 'a Base.Array.t
include sig ... end
val bin_read_t : 'a Bin_prot.Read.reader ‑> 'a t Bin_prot.Read.reader
val __bin_read_t__ : 'a Bin_prot.Read.reader ‑> (Core_kernel__.Import.int ‑> 'a t) Bin_prot.Read.reader
val bin_size_t : 'a Bin_prot.Size.sizer ‑> 'a t Bin_prot.Size.sizer
val bin_write_t : 'a Bin_prot.Write.writer ‑> 'a t Bin_prot.Write.writer
val bin_shape_t : Bin_prot.Shape.t ‑> Bin_prot.Shape.t

The signature included from Base.Array

include module type of sig ... end with type a t := a t
type 'a t = 'a array
val compare : ('a ‑> 'a ‑> int) ‑> 'a t ‑> 'a t ‑> int
val t_of_sexp : (Base.Sexp.t ‑> 'a) ‑> Base.Sexp.t ‑> 'a t
val sexp_of_t : ('a ‑> Base.Sexp.t) ‑> 'a t ‑> Base.Sexp.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 length : 'a t ‑> int
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, 'stop) Base.Container_intf.Continue_or_stop.t) ‑> ('accum, 'stop) Base.Container_intf.Finished_or_stopped_early.t
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.Commutative_group.S 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 ‑> cmp:('a ‑> 'a ‑> int) ‑> 'a option
val max_elt : 'a t ‑> cmp:('a ‑> 'a ‑> int) ‑> 'a option
val max_length : int
external get : 'a t ‑> int ‑> 'a =
external set : 'a t ‑> int ‑> 'a ‑> unit =
external unsafe_get : 'a t ‑> int ‑> 'a =
external unsafe_set : 'a t ‑> int ‑> 'a ‑> unit =
val create : len:int ‑> 'a ‑> 'a t
val init : int ‑> f:(int ‑> 'a) ‑> 'a t
val make_matrix : dimx:int ‑> dimy:int ‑> 'a ‑> '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 ‑> cmp:('a ‑> 'a ‑> int) ‑> unit
val stable_sort : 'a t ‑> cmp:('a ‑> 'a ‑> int) ‑> unit
val is_sorted : 'a t ‑> cmp:('a ‑> 'a ‑> int) ‑> bool
val is_sorted_strictly : 'a t ‑> cmp:('a ‑> 'a ‑> int) ‑> bool
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 normalize : 'a t ‑> int ‑> int
val slice : 'a t ‑> int ‑> int ‑> 'a t
val nget : 'a t ‑> int ‑> 'a
val nset : 'a t ‑> int ‑> 'a ‑> unit
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 of_list_rev : 'a list ‑> 'a t
val of_list_map : 'a list ‑> f:('a ‑> 'b) ‑> 'b t
val of_list_rev_map : 'a list ‑> f:('a ‑> 'b) ‑> 'b t
val replace : 'a t ‑> int ‑> f:('a ‑> 'a) ‑> unit
val replace_all : '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 ‑> '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 ‑> cmp:('a ‑> 'a ‑> int) ‑> 'a t
val last : 'a t ‑> 'a
val empty : unit ‑> 'a t
val equal : 'a t ‑> 'a t ‑> equal:('a ‑> 'a ‑> bool) ‑> bool
val unsafe_truncate : 'a t ‑> len:int ‑> unit
val to_sequence : 'a t ‑> 'a Base.Sequence.t
val to_sequence_mutable : 'a t ‑> 'a Base.Sequence.t

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.

module Permissioned = Core_kernel.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 realloc : 'a Core_kernel.Array.t ‑> len:int ‑> 'a ‑> 'a t