type 'a printer = Format.formatter -> 'a -> unitval get : ('a, 'b) Hashtbl.t -> 'a -> 'b optionSafe version of Hashtbl.find
val get_or : ('a, 'b) Hashtbl.t -> 'a -> or_:'b -> 'bget_or tbl k ~or_ returns the value associated to k if present, and returns or_ otherwise (if k doesn't belong in tbl)
Iterate on keys (similar order as Hashtbl.iter)
val keys_list : ('a, 'b) Hashtbl.t -> 'a listkeys_list t is the list of keys in t.
val values_list : ('a, 'b) Hashtbl.t -> 'b listvalues_list t is the list of values in t.
val map_list : ('a -> 'b -> 'c) -> ('a, 'b) Hashtbl.t -> 'c listMap on a hashtable's items, collect into a list
val incr : ?by:int -> ('a, int) Hashtbl.t -> 'a -> unitincr ?by tbl x increments or initializes the counter associated with x. If get tbl x = None, then after update, get tbl x = Some 1; otherwise, if get tbl x = Some n, now get tbl x = Some (n+1).
val decr : ?by:int -> ('a, int) Hashtbl.t -> 'a -> unitSame as incr but substract 1 (or the value of by). If the value reaches 0, the key is removed from the table. This does nothing if the key is not already present in the table.
val add_list : ('a, 'b list) Hashtbl.t -> 'a -> 'b -> unitadd_list tbl x y adds y to the list x is bound to. If x is not bound, it becomes bound to [y].
Add the corresponding pairs to the table, using Hashtbl.add.
add_seq_count tbl seq increments the count of each element of seq by calling incr. This is useful for counting how many times each element of seq occurs.
Similar to add_seq_count, but allocates a new table and returns it
val to_list : ('a, 'b) Hashtbl.t -> ('a * 'b) listList of bindings (order unspecified)
val of_list : ('a * 'b) list -> ('a, 'b) Hashtbl.tFrom the given list of bindings, added in order
val update :
('a, 'b) Hashtbl.t ->
f:('a -> 'b option -> 'b option) ->
k:'a ->
unitupdate tbl ~f ~k updates key k by calling f k (Some v) if k was mapped to v, or f k None otherwise; if the call returns None then k is removed/stays removed, if the call returns Some v' then the binding k -> v' is inserted using Hashtbl.replace
module type S = sig ... endmodule Make
(X : Hashtbl.HashedType) :
S with type key = X.t and type 'a t = 'a Hashtbl.Make(X).tA table with a default element for keys that were never added.
module type DEFAULT = sig ... endmodule MakeDefault (X : Hashtbl.HashedType) : DEFAULT with type key = X.tmodule type COUNTER = sig ... endmodule MakeCounter
(X : Hashtbl.HashedType) :
COUNTER with type elt = X.t and type t = int Hashtbl.Make(X).tCreate a new counter type The type t is exposed