`module Hashtbl: ``Extlib.ExtHashtbl.Hashtbl`

Operations over hashtables.type`('a, 'b)`

t =`('a, 'b) t`

The type of a hashtable.

`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 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 argument.`val is_empty : ``('a, 'b) t -> bool`

`Hashtbl.is_empty tbl`

returns `true`

if there are no bindings
in `tbl`

, false otherwise.`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 previous binding for `x`

, if any, is restored.
(Same behavior as with association lists.)`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 remove_all : ``('a, 'b) t -> 'a -> unit`

Remove all bindings for the given key

`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 copy : ``('a, 'b) t -> ('a, 'b) t`

Return a copy of the given hashtable.

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

Empty a hash table.

`val keys : ``('a, 'b) t -> 'a Enum.t`

Return an enumeration of all the keys of a hashtable.
If the key is in the Hashtable multiple times, all occurrences
will be returned.

`val values : ``('a, 'b) t -> 'b Enum.t`

Return an enumeration of all the values of a hashtable.

`val enum : ``('a, 'b) t -> ('a * 'b) Enum.t`

Return an enumeration of (key,value) pairs of a hashtable.

`val of_enum : ``('a * 'b) Enum.t -> ('a, 'b) t`

Create a hashtable from a (key,value) enumeration.

`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 current binding is returned first, then the previous
bindings, in reverse order of introduction in the table.`val find_default : ``('a, 'b) t -> 'a -> 'b -> 'b`

Find a binding for the key, and return a default
value if not found

`val find_option : ``('a, 'b) t -> 'a -> 'b option`

Find a binding for the key, or return

`None`

if no
value is found`val mem : ``('a, 'b) t -> 'a -> bool`

`Hashtbl.mem tbl x`

checks if `x`

is bound in `tbl`

.`exists h k`

returns true is at least one item with key `k`

is
found in the hashtable.
A number of higher-order functions are provided to allow
purely functional traversal or transformation of hashtables.
These functions are similar to their counterparts in module
`Enum`

.

Whenever you wish to traverse or transfor a hashtable, you have the
choice between using the more general functions of `Enum`

, with
`Hashtbl.keys`

, `Hashtbl.values`

, `Hashtbl.enum`

and `Hashtbl.of_enum`

, or the more optimized
functions of this section.

If you are new to OCaml or unsure about data structure, using the
functions of `Enum`

is a safe bet. Should you wish to improve
performance at the cost of generality, you will always be able to
rewrite your code to make use of the functions of this section.

`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 map : ``('a -> 'b -> 'c) ->`

('a, 'b) t -> ('a, 'c) t

`map f x`

creates a new hashtable with the same
keys as `x`

, but with the function `f`

applied to
all the values`val filter : ``('a -> bool) ->`

('b, 'a) t -> ('b, 'a) t

`filter f m`

returns a new hashtable where only the values `a`

of `m`

such that `f a = true`

remain.`val filteri : ``('a -> 'b -> bool) ->`

('a, 'b) t -> ('a, 'b) t

`filter f m`

returns a map where only the key, values pairs
`key`

, `a`

of `m`

such that `f key a = true`

remain. The
bindings are passed to `f`

in increasing order with respect
to the ordering over the type of the keys.`val filter_map : ``('a -> 'b -> 'c option) ->`

('a, 'b) t -> ('a, 'c) t

`filter_map f m`

combines the features of `filteri`

and
`map`

. It calls calls `f key0 a0`

, `f key1 a1`

, `f keyn an`

where `a0..an`

are the elements of `m`

and `key0..keyn`

the
respective corresponding keys. It returns the map of
pairs `keyi`

,`bi`

such as `f keyi ai = Some bi`

(when `f`

returns
`None`

, the corresponding element of `m`

is discarded).`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. 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.S-Expressions

`val t_of_sexp : ``(Sexplib.Sexp.t -> 'a) ->`

(Sexplib.Sexp.t -> 'b) ->

Sexplib.Sexp.t -> ('a, 'b) t

`val sexp_of_t : ``('a -> Sexplib.Sexp.t) ->`

('b -> Sexplib.Sexp.t) ->

('a, 'b) t -> Sexplib.Sexp.t

Printing

`val print : ``?first:string ->`

?last:string ->

?sep:string ->

('a Extlib.InnerIO.output -> 'b -> unit) ->

('a Extlib.InnerIO.output -> 'c -> unit) ->

'a Extlib.InnerIO.output -> ('b, 'c) t -> unit

The following modules replace functions defined in

`Hashtbl`

with functions
behaving slightly differently but having the same name. This is by design:
the functions meant to override the corresponding functions of `Hashtbl`

.
To take advantage of these overrides, you probably want to
or . For instance, to open a version of `Hashtbl`

with exceptionless error management, you may write ```
open Hashtbl,
Exceptionless
```

. To locally replace module `Hashtbl`

with a module of
the same name but with exceptionless error management, you may
write

module Hashtbl = Hashtbl include Exceptionless.

module Hashtbl.Exceptionless:`sig`

..`end`

Operations on

`Hashtbl`

without exceptions.
module Hashtbl.Labels:`sig`

..`end`

Operations on

`Hashtbl`

with labels.
module type HashedType =`sig`

..`end`

module type S =`sig`

..`end`

The output signature of the functor

`Hashtbl.Make`

.
module Hashtbl.Make:`functor (`

`H`

`:`

`Extlib.ExtHashtbl.Hashtbl.HashedType`

`) ->`

`Extlib.ExtHashtbl.Hashtbl.S`

`with type key = H.t`

Functor building an implementation of the hashtable structure.

module Hashtbl.Cap:`sig`

..`end`

Capabilities for hashtables.