Hashtbl(3o) - phpMan

Command: man perldoc info search(apropos)  


Hashtbl(3o)                               OCaml library                               Hashtbl(3o)



NAME
       Hashtbl - Hash tables and hash functions.

Module
       Module   Hashtbl

Documentation
       Module Hashtbl
        : sig end


       Hash tables and hash functions.

       Hash tables are hashed association tables, with in-place modification.








       === Generic interface ===

       type ('a, 'b) t


       The type of hash tables from type 'a to type 'b .




       val create : int -> ('a, 'b) t


       Hashtbl.create n creates a new, empty hash table, with initial size n .  For best results,
       n should be on the order of the expected number of elements that will  be  in  the  table.
       The table grows as needed, so n is just an initial guess.




       val clear : ('a, 'b) t -> unit

       Empty a hash table.




       val add : ('a, 'b) t -> 'a -> 'b -> unit


       Hashtbl.add  tbl  x y adds a binding of x to y in table tbl .  Previous bindings for x are
       not removed, but simply hidden. That is, after performing Hashtbl.remove tbl x , the  pre-
       vious binding for x , if any, is restored.  (Same behavior as with association lists.)




       val copy : ('a, 'b) t -> ('a, 'b) t

       Return a copy of the given hashtable.




       val find : ('a, 'b) t -> 'a -> 'b


       Hashtbl.find  tbl  x  returns  the current binding of x in tbl , or raises Not_found if no
       such binding exists.




       val find_all : ('a, 'b) t -> 'a -> 'b list


       Hashtbl.find_all tbl x returns the list of all data associated with x in tbl .   The  cur-
       rent  binding is returned first, then the previous bindings, in reverse order of introduc-
       tion in the table.




       val mem : ('a, 'b) t -> 'a -> bool


       Hashtbl.mem tbl x checks if x is bound in tbl .




       val remove : ('a, 'b) t -> 'a -> unit


       Hashtbl.remove tbl x removes the current binding of x in  tbl  ,  restoring  the  previous
       binding if it exists.  It does nothing if x is not bound in tbl .




       val replace : ('a, 'b) t -> 'a -> 'b -> unit


       Hashtbl.replace  tbl x y replaces the current binding of x in tbl by a binding of x to y .
       If x is unbound in tbl , a binding of x to y is added  to  tbl  .   This  is  functionally
       equivalent to Hashtbl.remove tbl x followed by Hashtbl.add tbl x y .




       val iter : ('a -> 'b -> unit) -> ('a, 'b) t -> unit


       Hashtbl.iter  f  tbl applies f to all bindings in table tbl .  f receives the key as first
       argument, and the associated value as second argument. Each binding is  presented  exactly
       once  to f .  The order in which the bindings are passed to f is unspecified.  However, if
       the table contains several bindings for the same key, they are  passed  to  f  in  reverse
       order of introduction, that is, the most recent binding is passed first.




       val fold : ('a -> 'b -> 'c -> 'c) -> ('a, 'b) t -> 'c -> 'c


       Hashtbl.fold  f  tbl  init computes (f kN dN ... (f k1 d1 init)...)  , where k1 ... kN are
       the keys of all bindings in tbl , and d1 ... dN are the associated values.   Each  binding
       is  presented  exactly  once  to  f  .  The order in which the bindings are passed to f is
       unspecified.  However, if the table contains several bindings for the same key,  they  are
       passed  to  f in reverse order of introduction, that is, the most recent binding is passed
       first.




       val length : ('a, 'b) t -> int


       Hashtbl.length tbl returns the number of bindings in tbl .  Multiple bindings are  counted
       multiply,  so  Hashtbl.length gives the number of times Hashtbl.iter calls its first argu-
       ment.





       === Functorial interface ===

       module type HashedType = sig end


       The input signature of the functor Hashtbl.Make .



       module type S = sig end


       The output signature of the functor Hashtbl.Make .



       module Make : functor (H : HashedType) -> sig end


       Functor building an implementation of the hashtable structure.  The  functor  Hashtbl.Make
       returns a structure containing a type key of keys and a type 'a t of hash tables associat-
       ing data of type 'a to keys of type key .  The operations perform similarly  to  those  of
       the generic interface, but use the hashing and equality functions specified in the functor
       argument H instead of generic equality and hashing.





       === The polymorphic hash primitive ===


       val hash : 'a -> int


       Hashtbl.hash x associates a positive integer to any value of any type.  It  is  guaranteed
       that  if  x  =  y  or  Pervasives.compare x y = 0 , then hash x = hash y .  Moreover, hash
       always terminates, even on cyclic structures.




       val hash_param : int -> int -> 'a -> int


       Hashtbl.hash_param n m x computes a hash value for x , with the  same  properties  as  for
       hash  .  The  two extra parameters n and m give more precise control over hashing. Hashing
       performs a depth-first, right-to-left traversal of the structure  x  ,  stopping  after  n
       meaningful  nodes were encountered, or m nodes, meaningful or not, were encountered. Mean-
       ingful nodes are: integers; floating-point numbers;  strings;  characters;  booleans;  and
       constant  constructors.  Larger  values  of  m  and n means that more nodes are taken into
       account to compute the final hash value, and therefore collisions are less likely to  hap-
       pen.   However,  hashing  takes longer. The parameters m and n govern the tradeoff between
       accuracy and speed.






OCamldoc                                    2008-05-19                                Hashtbl(3o)

Generated by $Id: phpMan.php,v 4.49 2006/02/26 13:18:18 chedong Exp $ Author: Che Dong
On Apache
Under GNU General Public License
2012-05-24 09:09 @38.107.179.238 Crawled by CCBot/1.0 (+http://www.commoncrawl.org/bot.html)
Valid XHTML 1.0!Valid CSS!