# Weak.Make.3o man page

Weak.Make — Functor building an implementation of the weak hash set structure.

## Module

Module Weak.Make

## Documentation

Module **Make**

: **functor (H : Hashtbl.HashedType) -> sig end**

Functor building an implementation of the weak hash set structure. **H.equal** can't be the physical equality, since only shallow copies of the elements in the set are given to it.

**Parameters:**

"H"

**Hashtbl.HashedType**

*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 sets cannot be marshaled using **Pervasives.output_value** or the functions of the **Marshal** module.

*val create* : **int -> t**

**create n** creates a new empty weak hash set, of initial size **n** . The table will grow as needed.

*val clear* : **t -> unit**

Remove all elements from the table.

*val 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** .

*val 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** .

*val 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** .

*val find* : **t -> data -> data**

**find t x** returns an instance of **x** found in **t** . Raise **Not_found** if there is no such element.

*val find_all* : **t -> data -> data list**

**find_all t x** returns a list of all the instances of **x** found in **t** .

*val mem* : **t -> data -> bool**

**mem t x** returns **true** if there is at least one instance of **x** in **t** , false otherwise.

*val 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.

*val 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.

*val 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.

*val 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.