module type S' = CCHashtbl.S
include Hashtbl.S
val get : 'a t -> key -> 'a option
Safe version of Hashtbl.find
val get_or : 'a t -> key -> default:'a -> 'a
get_or tbl k ~default returns the value associated to k if present,
and returns default otherwise (if k doesn't belong in tbl)
Since 0.16
val add_list : 'a list t -> key -> 'a -> unit
add_list tbl x y adds y to the list x is bound to. If x is
not bound, it becomes bound to [y].
Since 0.16
val incr : ?by:int -> int t -> key -> unit
incr ?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).
Since 0.16
by : if specified, the int value is incremented by by rather than 1
val decr : ?by:int -> int t -> key -> unit
Same as
CCHashtbl.S.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.
Since 0.16
val keys : 'a t -> key CCHashtbl.sequence
Iterate on keys (similar order as Hashtbl.iter)
val values : 'a t -> 'a CCHashtbl.sequence
Iterate on values in the table
val keys_list : 'a t -> key list
keys t is the list of keys in t.
Since 0.8
val values_list : 'a t -> 'a list
values t is the list of values in t.
Since 0.8
val map_list : (key -> 'a -> 'b) -> 'a t -> 'b list
Map on a hashtable's items, collect into a list
val to_seq : 'a t -> (key * 'a) CCHashtbl.sequence
Iterate on values in the table
val of_seq : (key * 'a) CCHashtbl.sequence -> 'a t
From the given bindings, added in order
val add_seq : 'a t -> (key * 'a) CCHashtbl.sequence -> unit
Add the corresponding pairs to the table, using Hashtbl.add.
Since 0.16
val add_seq_count : int t -> key CCHashtbl.sequence -> unit
add_seq_count tbl seq increments the count of each element of
seq
by calling
CCHashtbl.S.incr. This is useful for counting how many times each
element of
seq occurs.
Since 0.16
val of_seq_count : key CCHashtbl.sequence -> int t
val to_list : 'a t -> (key * 'a) list
List of bindings (order unspecified)
val of_list : (key * 'a) list -> 'a t
Build 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 t -> f:(key -> 'a option -> 'a option) -> k:key -> unit
update 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
Since 0.14
val get_or_add : 'a t -> f:(key -> 'a) -> k:key -> 'a
get_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.
Since 1.0
val print : key CCHashtbl.printer -> 'a CCHashtbl.printer -> 'a t CCHashtbl.printer
Printer for tables
Since 0.13