## Generic interface

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

## Functorial interface

`module type HashedType = sig ... end`
`module type S = sig ... end`

This is a subset of Hashtbl.S, kept as a separate interface to avoid compatibility issues when Hashtbl.S evolves.

`module Make (H : HashedType) : S with type key = H.t`

Functor building an implementation of the hashtable structure. The functor `Weaktbl.Make` returns a structure containing a type `key` of keys and a type `'a t` of hash tables associating data of type `'a` to keys of type `key`. The operations perform similarly to those of the generic interface, but use the hashing and equality functions specified in the functor argument `H` instead of generic equality and hashing.