type 'a printer = Format.formatter -> 'a -> unitThis sub-module contains the extension of the standard polymorphic hashtbl.
module Poly : sig ... endinclude module type of Polyval get : ('a, 'b) Hashtbl.t -> 'a -> 'b optionSafe version of Hashtbl.find
val get_or : ('a, 'b) Hashtbl.t -> 'a -> default:'b -> 'bget_or tbl k ~default returns the value associated to k if present, and returns default 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.tBuild a table from the given list of bindings k_i -> v_i, added in order using add. If a key occurs several times, it will be added several times, and the visible binding will be the last one.
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
val get_or_add : ('a, 'b) Hashtbl.t -> f:('a -> 'b) -> k:'a -> 'bget_or_add tbl ~k ~f finds and returns the binding of k in tbl, if it exists. If it does not exist, then f k is called to obtain a new binding v; k -> v is added to tbl and v is returned.
module type S = sig ... endmodule Make
(X : Hashtbl.HashedType) :
S with type key = X.t and type 'a t = 'a Hashtbl.Make(X).t