Module type Core_hashtbl_intf.Access_sig.S


module type S = sig .. end

val clear : ('a, 'b) T.t -> unit
val copy : ('a, 'b) T.t -> ('a, 'b) T.t
val invariant : ('a, 'b) T.t -> unit
val fold : ('a, 'b) T.t ->
init:'c -> f:(key:'a Core_hashtbl_intf.Key.t -> data:'b -> 'c -> 'c) -> 'c
val iter : ('a, 'b) T.t -> f:(key:'a Core_hashtbl_intf.Key.t -> data:'b -> unit) -> unit
val existsi : ('a, 'b) T.t -> f:(key:'a Core_hashtbl_intf.Key.t -> data:'b -> bool) -> bool
val exists : ('a, 'b) T.t -> f:('b -> bool) -> bool
val length : ('a, 'b) T.t -> int
val is_empty : ('a, 'b) T.t -> bool
val mem : ('a, 'b) T.t -> 'a Core_hashtbl_intf.Key.t -> bool
val remove : ('a, 'b) T.t -> 'a Core_hashtbl_intf.Key.t -> unit
val remove_one : ('a, 'b list) T.t -> 'a Core_hashtbl_intf.Key.t -> unit
val replace : ('a, 'b) T.t -> key:'a Core_hashtbl_intf.Key.t -> data:'b -> unit
val change : ('a, 'b) T.t ->
'a Core_hashtbl_intf.Key.t -> ('b option -> 'b option) -> unit
change t key f updates the given table by changing the value stored under key according to f, just like Map.change (see that for example).
val add_multi : ('a, 'b list) T.t -> key:'a Core_hashtbl_intf.Key.t -> data:'b -> unit
val map : ('a, 'b) T.t -> f:('b -> 'c) -> ('a, 'c) T.t
map t f returns new table with bound values replaced by f applied to the bound values
val mapi : ('a, 'b) T.t ->
f:(key:'a Core_hashtbl_intf.Key.t -> data:'b -> 'c) -> ('a, 'c) T.t
like map, but function takes both key and data as arguments
val filter_map : ('a, 'b) T.t -> f:('b -> 'c option) -> ('a, 'c) T.t
returns new map with bound values filtered by f applied to the bound values
val filter_mapi : ('a, 'b) T.t ->
f:(key:'a Core_hashtbl_intf.Key.t -> data:'b -> 'c option) -> ('a, 'c) T.t
like filter_map, but function takes both key and data as arguments
val filter : ('a, 'b) T.t -> f:('b -> bool) -> ('a, 'b) T.t
val filteri : ('a, 'b) T.t ->
f:(key:'a Core_hashtbl_intf.Key.t -> data:'b -> bool) -> ('a, 'b) T.t
val find_or_add : ('a, 'b) T.t -> 'a Core_hashtbl_intf.Key.t -> default:(unit -> 'b) -> 'b
find_or_add t k ~default returns the data associated with key k if it is in the table t, otherwise it lets d = default() and adds it to the table.
val find : ('a, 'b) T.t -> 'a Core_hashtbl_intf.Key.t -> 'b option
find t k returns Some (the current binding) of k in t, or None if no such binding exists
val find_exn : ('a, 'b) T.t -> 'a Core_hashtbl_intf.Key.t -> 'b
find_exn t k returns the current binding of k in t, or raises Not_found if no such binding exists.

iter_vals t ~f is like iter, except it only supplies the value to f, not the key.

val iter_vals : ('a, 'b) T.t -> f:('b -> unit) -> unit

Merge two hashtables.

The result of merge f h1 h2 has as keys the set of all k in the union of the sets of keys of h1 and h2 for which d(k) is not None, where:

d(k) =

Each key k is mapped to a single piece of data x, where d(k) = Some x.
val merge : f:(key:'a Core_hashtbl_intf.Key.t -> 'b option -> 'c option -> 'd option) ->
('a, 'b) T.t -> ('a, 'c) T.t -> ('a, 'd) T.t
val merge_into : f:(key:'a Core_hashtbl_intf.Key.t -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) T.t -> dst:('a, 'b) T.t -> unit
Merge one hashtable into another.

After merge_into f src dst, for every key in src, key will be re-mapped in dst to v if f ~key d1 (find dst key) = Some v.

val keys : ('a, 'b) T.t -> 'a Core_hashtbl_intf.Key.t list
Returns the list of all unique keys for given hashtable. Keys bound multiple times will not be returned twice.

Returns the list of all data for given hashtable.

val data : ('a, 'b) T.t -> 'b list
filter_inplace t ~f removes all the elements from t that don't * satisfy f.
val filter_inplace : ('a, 'b) T.t -> f:('b -> bool) -> unit
val filteri_inplace : ('a, 'b) T.t -> f:('a Core_hashtbl_intf.Key.t -> 'b -> bool) -> unit
val equal : ('a, 'b) T.t -> ('a, 'b) T.t -> ('b -> 'b -> bool) -> bool
val to_alist : ('a, 'b) T.t -> ('a Core_hashtbl_intf.Key.t * 'b) list
Returns the list of all (key,data) pairs for given hashtable.
val incr : ?by:int -> ('a, int) T.t -> 'a Core_hashtbl_intf.Key.t -> unit