`CCHashtbl`

Extension to the standard Hashtbl

This sub-module contains the extension of the standard polymorphic Hashtbl.

`module Poly : sig ... end`

`include module type of Poly`

`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 iter`

`keys tbl f`

iterates on keys (similar order as `Hashtbl`

.iter).

`val values : ( 'a, 'b ) Stdlib.Hashtbl.t -> 'b 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.

`values_list tbl`

is the list of values in `tbl`

.

`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) 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) 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) 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) iter -> ( 'a, 'b ) Stdlib.Hashtbl.t`

From the given bindings, added in order.

```
val of_iter_with :
f:( 'a -> 'b -> 'b -> 'b ) ->
('a * 'b) 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.

```
val of_seq_with :
f:( 'a -> 'b -> 'b -> 'b ) ->
('a * 'b) Stdlib.Seq.t ->
( '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.

`val add_iter_count : ( 'a, int ) Stdlib.Hashtbl.t -> 'a 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 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 printer ->
?pp_stop:unit printer ->
?pp_sep:unit printer ->
?pp_arrow:unit printer ->
'a printer ->
'b printer ->
( 'a, 'b ) Stdlib.Hashtbl.t 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 = sig ... end`