dwww Home | Manual pages | Find package

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

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 -> '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 hap-
       pens if f tries to change t itself.

       val count : t -> int

       Count the number of elements in the table.  count t gives the same  re-
       sult  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                          2023-02-12                     Weak.Make(3o)

Generated by dwww version 1.15 on Sun Jun 23 03:30:38 CEST 2024.