Weak.Make(3)                     OCaml library                    Weak.Make(3)

NAME
       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"

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


       Raises Not_found if there is no such element.



       val find_opt : t -> data -> data option


       find_opt t x returns an instance of x found in t or None if there is no
       such element.


       Since 4.05



       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 -> 'acc -> 'acc) -> t -> 'acc -> 'acc


       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.



OCamldoc                          2024-02-29                      Weak.Make(3)