module BatInnerWeaktbl:`sig`

..`end`

Weak hash table library for OCaml, with an interface compatible with the standard Hashtbl module.

`type ``('a, 'b)`

t

The type of hash tables from type `'a`

to type `'b`

.

`val create : ``int -> ('a, 'b) t`

`Weaktbl.create n`

creates a new, empty hash table, with
initial size `n`

. For best results, `n`

should be on the
order of the expected number of elements that will be in
the table. The table grows as needed, so `n`

is just an
initial guess.

`val clear : ``('a, 'b) t -> unit`

Empty a hash table.

`val add : ``('a, 'b) t -> 'a -> 'b -> unit`

`Weaktbl.add tbl x y`

adds a binding of `x`

to `y`

in table `tbl`

.
Previous bindings for `x`

are not removed, but simply
hidden. That is, after performing `Weaktbl.remove`

` tbl x`

,
the previous binding for `x`

, if any, is restored.
(Same behavior as with association lists.)

`val copy : ``('a, 'b) t -> ('a, 'b) t`

Return a copy of the given hashtable.

`val find : ``('a, 'b) t -> 'a -> 'b`

`Weaktbl.find tbl x`

returns the current binding of `x`

in `tbl`

,
or raises `Not_found`

if no such binding exists.

`val find_all : ``('a, 'b) t -> 'a -> 'b list`

`Weaktbl.find_all tbl x`

returns the list of all data
associated with `x`

in `tbl`

.
The current binding is returned first, then the previous
bindings, in reverse order of introduction in the table.

`val mem : ``('a, 'b) t -> 'a -> bool`

`Weaktbl.mem tbl x`

checks if `x`

is bound in `tbl`

.

`val remove : ``('a, 'b) t -> 'a -> unit`

`Weaktbl.remove tbl x`

removes the current binding of `x`

in `tbl`

,
restoring the previous binding if it exists.
It does nothing if `x`

is not bound in `tbl`

.

`val replace : ``('a, 'b) t -> 'a -> 'b -> unit`

`Weaktbl.replace tbl x y`

replaces the current binding of `x`

in `tbl`

by a binding of `x`

to `y`

. If `x`

is unbound in `tbl`

,
a binding of `x`

to `y`

is added to `tbl`

.
This is functionally equivalent to `Weaktbl.remove`

` tbl x`

followed by `Weaktbl.add`

` tbl x y`

.

`val iter : ``('a -> 'b -> unit) -> ('a, 'b) t -> unit`

`Weaktbl.iter f tbl`

applies `f`

to all bindings in table `tbl`

.
`f`

receives the key as first argument, and the associated value
as second argument. Each binding is presented exactly once to `f`

.
The order in which the bindings are passed to `f`

is unspecified.
However, if the table contains several bindings for the same key,
they are passed to `f`

in reverse order of introduction, that is,
the most recent binding is passed first.

`val fold : ``('a -> 'b -> 'c -> 'c) -> ('a, 'b) t -> 'c -> 'c`

`Weaktbl.fold f tbl init`

computes
`(f kN dN ... (f k1 d1 init)...)`

,
where `k1 ... kN`

are the keys of all bindings in `tbl`

,
and `d1 ... dN`

are the associated values.
Each binding is presented exactly once to `f`

.
The order in which the bindings are passed to `f`

is unspecified.
However, if the table contains several bindings for the same key,
they are passed to `f`

in reverse order of introduction, that is,
the most recent binding is passed first.

`val length : ``('a, 'b) t -> int`

`Weaktbl.length tbl`

returns the number of bindings in `tbl`

.
Multiple bindings are counted multiply, so `Weaktbl.length`

gives the number of times `Weaktbl.iter`

calls its first argument.

module Make:`functor (`

`H`

`:`

`Hashtbl.HashedType`

`) ->`

`Hashtbl.S`

`with type key = H.t`

Functor building an implementation of the hashtable structure.