Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
Weak.Make(3)			   OCamldoc			  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"

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

2020-08-11			    source:			  Weak.Make(3)

NAME | Module | Documentation

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=Weak.Make&sektion=3o&manpath=FreeBSD+12.2-RELEASE+and+Ports>

home | help