Containers.Hashtbl
include module type of Stdlib.Hashtbl with type statistics = Stdlib.Hashtbl.statistics and module Make
= Stdlib.Hashtbl.Make and type ('a, 'b) t = ('a, 'b) Stdlib.Hashtbl.t
val create : ?random:bool -> int -> ('a, 'b) t
val clear : ('a, 'b) t -> unit
val reset : ('a, 'b) t -> unit
val add : ('a, 'b) t -> 'a -> 'b -> unit
val find : ('a, 'b) t -> 'a -> 'b
val find_opt : ('a, 'b) t -> 'a -> 'b option
val find_all : ('a, 'b) t -> 'a -> 'b list
val mem : ('a, 'b) t -> 'a -> bool
val remove : ('a, 'b) t -> 'a -> unit
val replace : ('a, 'b) t -> 'a -> 'b -> unit
val iter : ('a -> 'b -> unit) -> ('a, 'b) t -> unit
val filter_map_inplace : ('a -> 'b -> 'b option) -> ('a, 'b) t -> unit
val fold : ('a -> 'b -> 'c -> 'c) -> ('a, 'b) t -> 'c -> 'c
val length : ('a, 'b) t -> int
val stats : ('a, 'b) t -> statistics
val to_seq : ('a, 'b) t -> ('a * 'b) Stdlib.Seq.t
val to_seq_keys : ('a, 'b) t -> 'a Stdlib.Seq.t
val to_seq_values : ('a, 'b) t -> 'b Stdlib.Seq.t
val replace_seq : ('a, 'b) t -> ('a * 'b) Stdlib.Seq.t -> unit
module type HashedType = sig ... end
module type S = sig ... end
module type SeededHashedType = sig ... end
module type SeededS = sig ... end
module MakeSeeded (H : SeededHashedType) : sig ... end
include module type of struct include CCHashtbl.Poly end
get tbl k
finds a binding for the key k
if present, or returns None
if no value is found. Safe version of Hashtbl.find
.
get_or tbl k ~default
returns the value associated to k
if present, and returns default
otherwise (if k
doesn't belong in tbl
).
val keys : ('a, 'b) Stdlib.Hashtbl.t -> 'a CCHashtbl.iter
keys tbl f
iterates on keys (similar order as Hashtbl.iter
).
val values : ('a, 'b) Stdlib.Hashtbl.t -> 'b CCHashtbl.iter
values tbl f
iterates on values in the table tbl
.
keys_list tbl
is the list of keys in tbl
. If the key is in the Hashtable multiple times, all occurrences will be returned.
map_list f tbl
maps on a tbl
's items. Collect into a list.
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)
.
decr ?by tbl x
is like incr
but subtract 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 to_iter : ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) CCHashtbl.iter
Iterate on bindings in the table.
add_list tbl x y
adds y
to the list x
is bound to. If x
is not bound, it becomes bound to y
.
val add_iter : ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) CCHashtbl.iter -> unit
Add the corresponding pairs to the table, using Hashtbl.add
.
val add_iter_with : f:('a -> 'b -> 'b -> 'b) ->
('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) CCHashtbl.iter -> unit
Add the corresponding pairs to the table, using Hashtbl.add
. If a key occurs multiple times in the input, the values are combined using f
in an unspecified order.
Add the corresponding pairs to the table, using Hashtbl.add
. Renamed from add_std_seq
since 3.0.
val add_seq_with : f:('a -> 'b -> 'b -> 'b) ->
('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) Stdlib.Seq.t -> unit
Add the corresponding pairs to the table. If a key occurs multiple times in the input, the values are combined using f
in an unspecified order.
val of_iter : ('a * 'b) CCHashtbl.iter -> ('a, 'b) Stdlib.Hashtbl.t
From the given bindings, added in order.
val of_iter_with : f:('a -> 'b -> 'b -> 'b) -> ('a * 'b) CCHashtbl.iter -> ('a, 'b) Stdlib.Hashtbl.t
From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f
in an unspecified order.
From the given bindings, added in order. Renamed from of_std_seq
since 3.0.
From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f
in an unspecified order.
val add_iter_count : ('a, int) Stdlib.Hashtbl.t -> 'a CCHashtbl.iter -> unit
add_iter_count tbl i
increments the count of each element of i
by calling incr
. This is useful for counting how many times each element of i
occurs.
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. Renamed from add_std_seq_count
since 3.0.
val of_iter_count : 'a CCHashtbl.iter -> ('a, int) Stdlib.Hashtbl.t
Like add_seq_count
, but allocates a new table and returns it.
Like add_seq_count
, but allocates a new table and returns it. Renamed from of_std_seq_count
since 3.0.
to_list tbl
returns the list of (key,value) bindings (order unspecified).
of_list l
builds a table from the given list l
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.
From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f
in an unspecified order.
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
.
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.
val pp : ?pp_start:unit CCHashtbl.printer -> ?pp_stop:unit CCHashtbl.printer -> ?pp_sep:unit CCHashtbl.printer -> ?pp_arrow:unit CCHashtbl.printer ->
'a CCHashtbl.printer -> 'b CCHashtbl.printer -> ('a, 'b) Stdlib.Hashtbl.t CCHashtbl.printer
pp ~pp_start ~pp_stop ~pp_sep ~pp arrow pp_k pp_v
returns a table printer given a pp_k
printer for individual key and a pp_v
printer for individual value. pp_start
and pp_stop
control the opening and closing delimiters, by default print nothing. pp_sep
control the separator between binding. pp_arrow
control the arrow between the key and value. Renamed from print
since 2.0.
module type S' = CCHashtbl.S
module Make' = CCHashtbl.Make