`module type S = sig .. end`

The output signature of the functor

`Weak.Make`

.```
type data;
```

The type of the elements stored in the table.

```
type t;
```

The type of tables that contain elements of type

`data`

.
Note that weak hash tables cannot be marshaled using
`Pervasives.output_value`

or the functions of the `Marshal`

module.```
let create: int => t;
```

`create n`

creates a new empty weak hash table, of initial
size `n`

. The table will grow as needed.```
let clear: t => unit;
```

Remove all elements from the table.

```
let merge: (t, data) => data;
```

`merge t x`

returns an instance of `x`

found in `t`

if any,
or else adds `x`

to `t`

and return `x`

.```
let add: (t, data) => unit;
```

`add t x`

adds `x`

to `t`

. If there is already an instance
of `x`

in `t`

, it is unspecified which one will be
returned by subsequent calls to `find`

and `merge`

.```
let remove: (t, data) => unit;
```

`remove t x`

removes from `t`

one instance of `x`

. Does
nothing if there is no instance of `x`

in `t`

.```
let find: (t, data) => data;
```

`find t x`

returns an instance of `x`

found in `t`

.
Raise `Not_found`

if there is no such element.```
let find_all: (t, data) => list(data);
```

`find_all t x`

returns a list of all the instances of `x`

found in `t`

.```
let mem: (t, data) => bool;
```

`mem t x`

returns `true`

if there is at least one instance
of `x`

in `t`

, false otherwise.```
let iter: (data => unit, t) => unit;
```

`iter f t`

calls `f`

on each element of `t`

, in some unspecified
order. It is not specified what happens if `f`

tries to change
`t`

itself.```
let fold: ((data, 'a) => 'a, t, 'a) => 'a;
```

`fold f t init`

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

where
`d1 ... dN`

are the elements of `t`

in some unspecified order.
It is not specified what happens if `f`

tries to change `t`

itself.```
let count: t => int;
```

Count the number of elements in the table.

`count t`

gives the
same result as `fold (fun _ n -> n+1) t 0`

but does not delay the
deallocation of the dead elements.```
let stats: t => (int, int, int, int, int, int);
```

Return statistics on the table. The numbers are, in order:
table length, number of entries, sum of bucket lengths,
smallest bucket length, median bucket length, biggest bucket length.