Module CCHashtbl

module CCHashtbl: sig .. end

Extension to the standard Hashtbl


Since 0.4

type 'a sequence = ('a -> unit) -> unit 
type 'a eq = 'a -> 'a -> bool 
type 'a hash = 'a -> int 
type 'a printer = Format.formatter -> 'a -> unit 

Polymorphic tables


val get : ('a, 'b) Hashtbl.t -> 'a -> 'b option
Safe version of Hashtbl.find
val get_or : ('a, 'b) Hashtbl.t -> 'a -> or_:'b -> 'b
get_or tbl k ~or_ returns the value associated to k if present, and returns or_ otherwise (if k doesn't belong in tbl)
Since 0.16
val keys : ('a, 'b) Hashtbl.t -> 'a sequence
Iterate on keys (similar order as Hashtbl.iter)
val values : ('a, 'b) Hashtbl.t -> 'b sequence
Iterate on values in the table
val keys_list : ('a, 'b) Hashtbl.t -> 'a list
keys_list t is the list of keys in t.
Since 0.8
val values_list : ('a, 'b) Hashtbl.t -> 'b list
values_list t is the list of values in t.
Since 0.8
val map_list : ('a -> 'b -> 'c) -> ('a, 'b) Hashtbl.t -> 'c list
Map on a hashtable's items, collect into a list
val incr : ?by:int -> ('a, int) Hashtbl.t -> 'a -> 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 -> ('a, int) Hashtbl.t -> 'a -> unit
Same as CCHashtbl.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 to_seq : ('a, 'b) Hashtbl.t -> ('a * 'b) sequence
Iterate on bindings in the table
val add_list : ('a, 'b list) Hashtbl.t -> 'a -> 'b -> 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 add_seq : ('a, 'b) Hashtbl.t -> ('a * 'b) sequence -> unit
Add the corresponding pairs to the table, using Hashtbl.add.
Since 0.16
val of_seq : ('a * 'b) sequence -> ('a, 'b) Hashtbl.t
From the given bindings, added in order
val add_seq_count : ('a, int) Hashtbl.t -> 'a sequence -> unit
add_seq_count tbl seq increments the count of each element of seq by calling CCHashtbl.incr. This is useful for counting how many times each element of seq occurs.
Since 0.16
val of_seq_count : 'a sequence -> ('a, int) Hashtbl.t
Similar to CCHashtbl.add_seq_count, but allocates a new table and returns it
Since 0.16
val to_list : ('a, 'b) Hashtbl.t -> ('a * 'b) list
List of bindings (order unspecified)
val of_list : ('a * 'b) list -> ('a, 'b) Hashtbl.t
From the given list of bindings, added in order
val update : ('a, 'b) Hashtbl.t -> f:('a -> 'b option -> 'b option) -> k:'a -> 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 print : 'a printer ->
'b printer -> ('a, 'b) Hashtbl.t printer
Printer for table
Since 0.13

Functor


module type S = sig .. end
module Make (X : Hashtbl.HashedType) : S  with type key = X.t and type 'a t = 'a Hashtbl.Make(X).t

Default Table

A table with a default element for keys that were never added.

module type DEFAULT = sig .. end
module MakeDefault (X : Hashtbl.HashedType) : DEFAULT  with type key = X.t

Count occurrences using a Hashtbl


module type COUNTER = sig .. end
module MakeCounter (X : Hashtbl.HashedType) : COUNTER 
  with type elt = X.t
  and type t = int Hashtbl.Make(X).t
Create a new counter type The type t is exposed