module Hashtbl.Cap:Capabilities for hashtables.`sig`

..`end`

`type ``('a, 'b, [< `Read | `Write ])`

t

The type of a hashtable.

`val create : ``int -> ('a, 'b, [< `Read | `Write ]) 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 of_table : ``('a, 'b) Hashtbl.t ->`

('a, 'b, [< `Read | `Write ]) t

Adopt a regular hashtable as a capability hashtble, allowing
to decrease capabilities if necessary.

This operation involves no copying. In other words, in
`let cap = of_table a in ...`

, any modification in `a`

will also have effect on `cap`

and reciprocally.

`val to_table : ``('a, 'b, [ `Read | `Write ]) t ->`

('a, 'b) Hashtbl.t

Return a capability hashtable as a regular hashtable.

This operation requires both read and write permissions
on the capability table and involves no copying. In other
words, in `let a = of_table cap in ...`

, any modification
in `a`

will also have effect on `cap`

and reciprocally.

`val read_only : ``('a, 'b, [< `Read | `Write > `Read ]) t ->`

('a, 'b, [ `Read ]) t

Drop to read-only permissions.

This operation involves no copying.

`val write_only : ``('a, 'b, [< `Read | `Write > `Write ]) t ->`

('a, 'b, [ `Write ]) t

Drop to write-only permissions.

This operation involves no copying.

`val length : ``('a, 'b, [< `Read | `Write ]) 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, [< `Read | `Write ]) t -> bool`

`Hashtbl.is_empty tbl`

returns `true`

if there are no bindings
in `tbl`

, false otherwise.`val add : ``('a, 'b, [< `Read | `Write > `Write ]) 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, [< `Read | `Write > `Write ]) 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, [< `Read | `Write > `Write ]) t ->`

'a -> unit

Remove all bindings for the given key

`val replace : ``('a, 'b, [< `Read | `Write > `Write ]) 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, [< `Read | `Write > `Read ]) t ->`

('a, 'b, [< `Read | `Write ]) t

Return a copy of the given hashtable.

`val clear : ``('a, 'b, [< `Read | `Write > `Write ]) t ->`

unit

Empty a hash table.

`val find : ``('a, 'b, [< `Read | `Write > `Read ]) 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, [< `Read | `Write > `Read ]) 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, [< `Read | `Write > `Read ]) t ->`

'a -> 'b -> 'b

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

`val find_option : ``('a, 'b, [< `Read | `Write > `Read ]) t ->`

'a -> 'b option

Find a binding for the key, or return

`None`

if no
value is found`val mem : ``('a, 'b, [< `Read | `Write > `Read ]) 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.`val iter : ``('a -> 'b -> unit) ->`

('a, 'b, [< `Read | `Write > `Read ]) 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, [< `Read | `Write > `Read ]) 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, [< `Read | `Write > `Read ]) t ->

('a, 'c, [< `Read | `Write ]) 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, [< `Read | `Write > `Read ]) t ->

('b, 'a, [< `Read | `Write ]) 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, [< `Read | `Write > `Read ]) t ->

('a, 'b, [< `Read | `Write ]) 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, [< `Read | `Write > `Read ]) t ->

('a, 'c, [< `Read | `Write ]) 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 keys : ``('a, 'b, [< `Read | `Write > `Read ]) 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, [< `Read | `Write > `Read ]) t ->`

'b Enum.t

Return an enumeration of all the values of a hashtable.

`val enum : ``('a, 'b, [< `Read | `Write > `Read ]) t ->`

('a * 'b) Enum.t

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

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

('a, 'b, [< `Read | `Write ]) t

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

S-Expressions

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

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

Sexplib.Sexp.t ->

('a, 'b, [< `Read | `Write ]) t

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

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

('a, 'b, [< `Read | `Write > `Read ]) 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, [< `Read | `Write > `Read ]) 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.Cap include Exceptionless.

module Hashtbl.Cap.Exceptionless:`sig`

..`end`

Operations on

`Hashtbl`

without exceptions.
module Hashtbl.Cap.Labels:`sig`

..`end`

Operations on

`Hashtbl`

with labels.