core-and-more 0.0.1 (latest)

Parameters

module K : sig ... end

module V : sig ... end

type key = K.t

val compare_key : key -> key -> Ppx_deriving_runtime.int

val pp_key : 
  Ppx_deriving_runtime.Format.formatter ->
  key ->
  Ppx_deriving_runtime.unit

val show_key : key -> Ppx_deriving_runtime.string

val equal_key : key -> key -> Ppx_deriving_runtime.bool

val hash_fold_key : Base.Hash.state -> key -> Base.Hash.state

val hash_key : key -> Base.Hash.hash_value

type value = V.t

val compare_value : value -> value -> Ppx_deriving_runtime.int

val pp_value : 
  Ppx_deriving_runtime.Format.formatter ->
  value ->
  Ppx_deriving_runtime.unit

val show_value : value -> Ppx_deriving_runtime.string

val equal_value : value -> value -> Ppx_deriving_runtime.bool

val hash_fold_value : Base.Hash.state -> value -> Base.Hash.state

val hash_value : value -> Base.Hash.hash_value

module CompareDict : sig ... end

type t =

val compare : t -> t -> Ppx_deriving_runtime.int

val pp : 
  Ppx_deriving_runtime.Format.formatter ->
  t ->
  Ppx_deriving_runtime.unit

val show : t -> Ppx_deriving_runtime.string

val hash_fold_t : Base.Hash.state -> t -> Base.Hash.state

val hash : t -> Base.Hash.hash_value

val empty : t

val mk_leaf : key -> value -> t

val mk_branch : int -> int -> t -> t -> t

val zero_bit : int -> int -> bool

val contains_key : t -> K.t -> bool

val lookup : t -> K.t -> value option

val lowest_bit : int -> int

val branching_bit : int -> int -> int

val mask : int -> int -> int

val unsigned_lt : int -> int -> bool

val join : (int * t * int * t) -> t

val match_prefix : int -> int -> int -> bool

val insert_or_combine : 
  combiner:(value -> value -> value) ->
  t ->
  key ->
  value ->
  t

val insert : t -> key -> value -> t

val remove : K.t -> t -> t

val as_kvp_list : t -> (key * value) list

val merge_to_dict : combiner:(value -> value -> value) -> t -> t -> t

val merge : 
  combiner:(value -> value -> 'a) ->
  only_d1_fn:(value -> 'a0) ->
  only_d2_fn:(value -> 'a1) ->
  t ->
  t ->
  (key * 'a2) list

val iter : f:(key -> value -> unit) -> t -> unit

val map : f:(value -> value) -> t -> t

val mapi : f:(key -> value -> value) -> t -> t

val fold : (key -> value -> 'a -> 'b) -> t -> 'c -> 'd