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

FreeBSD Manual Pages

  
 
  

home | help
Weak.Make(3)			 OCaml library			  Weak.Make(3)

NAME
       Weak.Make  -  Functor building an implementation	of the weak hash table
       structure.

Module
       Module	Weak.Make

Documentation
       Module Make
	: functor (H : Hashtbl.HashedType) -> sig end

       Functor building	an implementation of the weak hash table structure.

       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  tables  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 table, 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 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			  2017-04-30			  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.0-RELEASE+and+Ports>

home | help