module Make:
Functor building an implementation of the partial bijective hash
table structure.
type
Keys in the domain.
type
Elements in the range.
type
val length : t -> int
Number of entries in a bijective hash table.
val create : int -> t
create n is a new, empty bijective hash table with capacity
for
n entries.
val clear : t -> unit
Remove all entries from a hash table.
val copy : t -> t
A copy of the given hash table.
val mem : t -> key -> bool
mem b k holds when there is an entry for k in b.
val mem_inv : t -> elt -> bool
mem_inv b e holds when an entry in b maps some key to e.
val add : t -> key -> elt -> unit
add b k e adds an entry mapping
k to
e to
b.
val find : t -> key -> elt
find b k is the element to which
k is mapped by
b.
Raises Not_found if
not (Bihashtbl.S.mem b k)
val find_inv : t -> elt -> key
val remove_key : t -> key -> unit
remove_key b k removes any entry that maps the key
k from
b.
val remove_elt : t -> elt -> unit
remove_key b y removes any entry that maps to the element
e from
b.
val replace : t -> key -> elt -> unit
val iter : (key -> elt -> unit) -> t -> unit
iter c t applies
c to every entry in
b. Applications
are made in increasing order with respect
Bihashtbl.S.key.
val fold : (key -> elt -> 'a -> 'a) -> t -> 'a -> 'a
fold f b a is
(f kN eN ... (f k1 e1 a) ... ), where
b is
a collection of entries
{(k1,e1) ... (kN,eN)} ordered with
respect to
Bihashtbl.S.key.
Hosted by the
* web site.
*Other names and brands may be claimed as the property
of others.