include sig ... end
val t_of_sexp : (Base.Sexp.t ‑> 'a) ‑> (Base.Sexp.t ‑> 'b) ‑> Base.Sexp.t ‑> ('a, 'b) t
val sexp_of_t : ('a ‑> Base.Sexp.t) ‑> ('b ‑> Base.Sexp.t) ‑> ('a, 'b) t ‑> Base.Sexp.t
val hashable : 'a Base.Hashable.t
include Base.Invariant.S2 with type (a, b) t := (a, b) t
val invariant : 'a Base__.Invariant_intf.inv ‑> 'b Base__.Invariant_intf.inv ‑> ('a, 'b) t Base__.Invariant_intf.inv
include Base__.Hashtbl_intf.Creators_generic with type (a, b) t := (a, b) t with type 'a key = 'a with type (key, data, z) create_options := (key, data, z) Base__.Hashtbl_intf.create_options_without_first_class_module
val create : ('a key, 'b, unit ‑> ('a, 'b) t) create_options
val of_alist : ('a key, 'b, ('a key * 'b) list ‑> [ `Ok of ('a, 'b) t | `Duplicate_key of 'a key ]) create_options
val of_alist_report_all_dups : ('a key, 'b, ('a key * 'b) list ‑> [ `Ok of ('a, 'b) t | `Duplicate_keys of 'a key list ]) create_options
val of_alist_or_error : ('a key, 'b, ('a key * 'b) list ‑> ('a, 'b) t Base.Or_error.t) create_options
val of_alist_exn : ('a key, 'b, ('a key * 'b) list ‑> ('a, 'b) t) create_options
val of_alist_multi : ('a key, 'b list, ('a key * 'b) list ‑> ('a, 'b list) t) create_options
val create_mapped : ('a key, 'b, get_key:('r ‑> 'a key) ‑> get_data:('r ‑> 'b) ‑> 'r list ‑> [ `Ok of ('a, 'b) t | `Duplicate_keys of 'a key list ]) create_options
create_mapped get_key get_data [x1,...,xn]
= of_alist [get_key x1, get_data x1; ...; get_key xn, get_data xn]
val create_with_key : ('a key, 'r, get_key:('r ‑> 'a key) ‑> 'r list ‑> [ `Ok of ('a, 'r) t | `Duplicate_keys of 'a key list ]) create_options
create_with_key ~get_key [x1,...,xn]
= of_alist [get_key x1, x1; ...; get_key xn, xn]
val create_with_key_or_error : ('a key, 'r, get_key:('r ‑> 'a key) ‑> 'r list ‑> ('a, 'r) t Base.Or_error.t) create_options
val create_with_key_exn : ('a key, 'r, get_key:('r ‑> 'a key) ‑> 'r list ‑> ('a, 'r) t) create_options
val group : ('a key, 'b, get_key:('r ‑> 'a key) ‑> get_data:('r ‑> 'b) ‑> combine:('b ‑> 'b ‑> 'b) ‑> 'r list ‑> ('a, 'b) t) create_options
include Base__.Hashtbl_intf.Accessors with type (a, b) t := (a, b) t with type a key := a key
val sexp_of_key : ('a, _) t ‑> 'a key ‑> Base.Sexp.t
val clear : (_, _) t ‑> unit
Attempting to modify (set
, remove
, etc.) the hashtable during iteration (fold
,
iter
, iter_keys
, iteri
) will raise an exception.
val iter : (_, 'b) t ‑> f:('b ‑> unit) ‑> unit
val exists : (_, 'b) t ‑> f:('b ‑> bool) ‑> bool
val for_all : (_, 'b) t ‑> f:('b ‑> bool) ‑> bool
val count : (_, 'b) t ‑> f:('b ‑> bool) ‑> int
val length : (_, _) t ‑> int
val is_empty : (_, _) t ‑> bool
val partition_mapi : ('a, 'b) t ‑> f:(key:'a key ‑> data:'b ‑> [ `Fst of 'c | `Snd of 'd ]) ‑> ('a, 'c) t * ('a, 'd) t
like partition_map
, but function takes both key and data as arguments
returns a pair of tables (t1, t2)
, where t1
contains all the elements of the
initial table which satisfy the predicate f
, and t2
contains all the elements
which do not satisfy f
.
find_or_add t k ~default
returns the data associated with key k if it
is in the table t, otherwise it lets d = default() and adds it to the
table.
find_exn t k
returns the current binding of k in t, or raises Caml.Not_found
or
Not_found_s
if no such binding exists.
val find_and_call : ('a, 'b) t ‑> 'a key ‑> if_found:('b ‑> 'c) ‑> if_not_found:('a key ‑> 'c) ‑> 'c
find_and_call t k ~if_found ~if_not_found
is equivalent to:
match find t k with Some v -> if_found v | None -> if_not_found k
except that it doesn't allocate the option.
find_and_remove t k
returns Some (the current binding) of k in t and removes
it, or None is no such binding exists
val merge : ('k, 'a) t ‑> ('k, 'b) t ‑> f:(key:'k key ‑> [ `Left of 'a | `Right of 'b | `Both of 'a * 'b ] ‑> 'c option) ‑> ('k, 'c) t
Merge two hashtables.
The result of merge f h1 h2
has as keys the set of all k
in the
union of the sets of keys of h1
and h2
for which d(k)
is not
None, where:
d(k) =
k
in h1
is to d1, and h2
does not map k
;k
in h2
is to d2, and h1
does not map k
;k
in h1
is to d1
and k
in h2
is to d2
.Each key k
is mapped to a single piece of data x, where d(k)
= Some x.
val merge_into : src:('k, 'a) t ‑> dst:('k, 'b) t ‑> f:(key:'k key ‑> 'a ‑> 'b option ‑> 'b merge_into_action) ‑> unit
val filter_inplace : (_, 'b) t ‑> f:('b ‑> bool) ‑> unit
val map_inplace : (_, 'b) t ‑> f:('b ‑> 'b) ‑> unit
map_inplace t ~f
applies f to all elements in t
, transforming them in place
val filter_map_inplace : (_, 'b) t ‑> f:('b ‑> 'b option) ‑> unit
filter_map_inplace
combines the effects of map_inplace
and filter_inplace
equal t1 t2 f
and similar t1 t2 f
both return true iff t1
and t2
have the
same keys and for all keys k
, f (find_exn t1 k) (find_exn t2 k)
. equal
and
similar
only differ in their types.
val validate : name:('a key ‑> string) ‑> 'b Base.Validate.check ‑> ('a, 'b) t Base.Validate.check
include Base__.Hashtbl_intf.Multi with type (a, b) t := (a, b) t with type a key := a key
add_multi t ~key ~data
if key
is present in the table then cons
data
on the list, otherwise add key
with a single element list.