hashtbl: hash tables and hash functions
Hash tables are hashed association tables, with in-place modification.
type ('a, 'b) t
The type of hash tables from type 'a to type 'b.
value new : int -> ('a,'b) t
new n creates a new, empty hash table, with initial size n.
The table grows as needed, so n is just an initial guess.
Better results are said to be achieved when n is a prime
number. Raise Invalid_argument "hashtbl__new" if n is
less than 1.
value clear : ('a, 'b) t -> unit
Empty a hash table.
value add : ('a, 'b) t -> 'a -> 'b -> unit
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 remove tbl x, the previous
binding for x, if any, is restored.
(This is the semantics of association lists.)
value find : ('a, 'b) t -> 'a -> 'b
find tbl x returns the current binding of x in tbl,
or raises Not_found if no such binding exists.
value find_all : ('a, 'b) t -> 'a -> 'b list
find_all tbl x returns the list of all data associated with x
in tbl. The current binding is returned first, then the previous
bindings, in reverse order of introduction in the table.
value remove : ('a, 'b) t -> 'a -> unit
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.
value do_table : ('a -> 'b -> unit) -> ('a, 'b) t -> unit
do_table f tbl applies f to all bindings in table tbl,
discarding all the results.
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 unpredictable, except that successive bindings for the same
key are presented in reverse chronological order
(most recent first).
value do_table_rev : ('a -> 'b -> unit) -> ('a, 'b) t -> unit
Same as do_table, except that successive bindings for the same
key are presented in chronological order (oldest first).
The polymorphic hash primitive
value hash : 'a -> int
hash x associates a positive integer to any value of
any type. It is guaranteed that
if x = y, then hash x = hash y.
Moreover, hash always terminates, even on cyclic
value hash_param : int -> int -> 'a -> int
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. Meaningful 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 happen.
However, hashing takes longer. The parameters m and n
govern the tradeoff between accuracy and speed.