module Hashtbl = struct ... end
Types | |
'a 'b t |
The type of hash tables from type 'a to type 'b .Abstract |
Functions |
create
: int -> ('c, 'd) 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.
clear
: ('e, 'f) t -> unit |
add
: ('g, 'h) t -> key:'g -> data:'h -> 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 previous binding for x
, if any, is restored.
(Same behavior as with association lists.)
find
: ('i, 'j) t -> 'i -> 'j |
Hashtbl.find tbl x
returns the current binding of x
in tbl
,
or raises Not_found
if no such binding exists.
find_all
: ('k, 'l) t -> 'k -> 'l list |
Hashtbl.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.
mem
: ('m, 'n) t -> 'm -> bool |
Hashtbl.mem tbl x
checks if x
is bound in tbl
.
remove
: ('o, 'p) t -> 'o -> 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
.
replace
: ('q, 'r) t -> key:'q -> data:'r -> 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
.
iter
: f:(key:'s -> data:'t -> unit) -> ('s, 't) 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. The order in which the bindings are passed to
f
is unspecified. Each binding is presented exactly once
to f
.
fold
: f:(key:'u -> data:'v -> 'w -> 'w) -> ('u, 'v) t -> init:'w -> 'w |
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.
The order in which the bindings are passed to
f
is unspecified. Each binding is presented exactly once
to f
.
hash
: 'x -> int |
Hashtbl.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
structures.
hash_param
: int -> int -> 'y -> 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. 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.