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 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 : ('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 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) Base__.Result.t) ->
  ('acc, 'e) Base__.Result.t

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, 'a, 'b) Base__Indexed_container_intf.foldi

val iteri : ('a t, 'a) Base__Indexed_container_intf.iteri

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 Base__Invariant_intf.inv -> 'a t Base__Invariant_intf.inv

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 : ('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 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

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