package ppx_deriving_hardcaml

You can search for identifiers within the package.

in-package search v0.2.0

ppx_deriving_hardcaml.runtime
- Ppx_deriving_hardcaml_runtime
  - Array

Legend:
Library
Module
Module type
Parameter
Class
Class type

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 : ('a t, 'a, 'key) Base__Binary_searchable_intf.binary_search

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

val for_ : Base__Int.t -> f:(int -> 'a) -> unit