module type S = sig .. end
type
type 'a t
val empty : unit -> 'a t
Empty table. The table will be allocated at the first binding
val create : int -> 'a t
Create a new hashtable, with the given initial capacity
val is_empty : 'a t -> bool
Is the table empty?
val find : 'a t -> key -> 'a
Find the value for this key, or fails
Raises Not_found if the key is not present in the table
val get_exn : key -> 'a t -> 'a
val get : key -> 'a t -> 'a option
Safe version of !
val mem : 'a t -> key -> bool
Is the key bound?
val length : 'a t -> int
Number of bindings
val add : 'a t ->
key -> 'a -> 'a t
Add the binding to the table, returning a new table. The old binding
for this key, if it exists, is shadowed and will be restored upon
remove tbl k.
Since 0.14
val replace : 'a t ->
key -> 'a -> 'a t
Add the binding to the table, returning a new table. This erases
the current binding for key, if any.
val update : 'a t ->
key ->
('a option -> 'a option) -> 'a t
update tbl key f calls f None if key doesn't belong in tbl,
f (Some v) if key -> v otherwise; If f returns None then
key is removed, else it returns Some v' and key -> v' is added.
val remove : 'a t ->
key -> 'a t
Remove the key
val copy : 'a t -> 'a t
Fresh copy of the table; the underlying structure is not shared
anymore, so using both tables alternatively will be efficient
val merge : f:(key ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
'a t ->
'b t -> 'c t
Merge two tables together into a new table. The function's argument
correspond to values associated with the key (if present); if the
function returns None the key will not appear in the result.
val iter : 'a t ->
(key -> 'a -> unit) -> unit
Iterate over bindings
val fold : ('b -> key -> 'a -> 'b) ->
'b -> 'a t -> 'b
Fold over bindings
val map : (key -> 'a -> 'b) ->
'a t -> 'b t
Map all values
val filter : (key -> 'a -> bool) ->
'a t -> 'a t
val filter_map : (key -> 'a -> 'b option) ->
'a t -> 'b t
val for_all : (key -> 'a -> bool) ->
'a t -> bool
val exists : (key -> 'a -> bool) ->
'a t -> bool
Conversions
val of_seq : (key * 'a) CCPersistentHashtbl.sequence ->
'a t
Add (replace) bindings from the sequence to the table
val of_list : (key * 'a) list -> 'a t
val add_seq : 'a t ->
(key * 'a) CCPersistentHashtbl.sequence ->
'a t
val add_list : 'a t ->
(key * 'a) list -> 'a t
val to_seq : 'a t ->
(key * 'a) CCPersistentHashtbl.sequence
Sequence of the bindings of the table
val to_list : 'a t -> (key * 'a) list
Misc
val equal : 'a CCPersistentHashtbl.equal ->
'a t CCPersistentHashtbl.equal
val pp : key CCPersistentHashtbl.printer ->
'a CCPersistentHashtbl.printer ->
'a t CCPersistentHashtbl.printer
val print : key CCPersistentHashtbl.formatter ->
'a CCPersistentHashtbl.formatter ->
'a t CCPersistentHashtbl.formatter
val stats : 'a t -> Hashtbl.statistics
Statistics on the internal table.
Since 0.14