Weak.Make man page on Cygwin

Man page or keyword search:  
man Server   22533 pages
apropos Keyword Search (all sections)
Output format
Cygwin logo
[printable version]

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
       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			  2013-10-24			  Weak.Make(3)
[top]

List of man pages available for Cygwin

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Tweet
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
....................................................................
Vote for polarhome
Free Shell Accounts :: the biggest list on the net