type nonrec ('a, 'b) t = ('a, 'b) t
include Bin_prot.Binable.S2 with type ('a, 'b) t := ('a, 'b) t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'b, ('a, 'b) t) Bin_prot.Size.sizer2
val bin_write_t : ('a, 'b, ('a, 'b) t) Bin_prot.Write.writer2
val bin_read_t : ('a, 'b, ('a, 'b) t) Bin_prot.Read.reader2
val __bin_read_t__ : ('a, 'b, int -> ('a, 'b) t) Bin_prot.Read.reader2
val bin_writer_t : ('a, 'b, ('a, 'b) t) Bin_prot.Type_class.S2.writer
val bin_reader_t : ('a, 'b, ('a, 'b) t) Bin_prot.Type_class.S2.reader
val bin_t : ('a, 'b, ('a, 'b) t) Bin_prot.Type_class.S2.t
include Core_kernel.Hashtbl_intf.Hashtbl.S_poly with type ('a, 'b) t := ('a, 'b) t
include Base.Sexpable.S2 with type ('a, 'b) t := ('a, 'b) t
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 -> unit) -> ('b -> unit) -> ('a, 'b) t -> unit
create_mapped get_key get_data [x1,...,xn]
= of_alist [get_key x1, get_data x1; ...; get_key xn, get_data xn]
create_with_key ~get_key [x1,...,xn]
= of_alist [get_key x1, x1; ...; get_key xn, xn]
val sexp_of_key : ('a, 'b) t -> 'a key -> Base.Sexp.t
val clear : ('a, 'b) t -> unit
Attempting to modify (set
, remove
, etc.) the hashtable during iteration (fold
, iter
, iter_keys
, iteri
) will raise an exception.
val iter : ('a, 'b) t -> f:('b -> unit) -> unit
Iterates over both keys and values.
Example:
let h = Hashtbl.of_alist_exn (module Int) [(1, 4); (5, 6)] in Hashtbl.iteri h ~f:(fun ~key ~data -> print_endline (Printf.sprintf "%d-%d" key data));; 1-4 5-6 - : unit = ()
val exists : ('a, 'b) t -> f:('b -> bool) -> bool
val for_all : ('a, 'b) t -> f:('b -> bool) -> bool
val count : ('a, 'b) t -> f:('b -> bool) -> int
val length : ('a, 'b) t -> int
val is_empty : ('a, 'b) t -> bool
add
and add_exn
leave the table unchanged if the key was already present.
change t key ~f
changes t
's value for key
to be f (find t key)
.
update t key ~f
is change t key ~f:(fun o -> Some (f o))
.
map t f
returns a new table with values replaced by the result of applying f
to the current values.
Example:
let h = Hashtbl.of_alist_exn (module Int) [(1, 4); (5, 6)] in let h' = Hashtbl.map h ~f:(fun x -> x * 2) in Hashtbl.to_alist h';; - : (int * int) list = [(5, 12); (1, 8)]
Like map
, but the function f
takes both key and data as arguments.
Returns a new table by filtering the given table's values by f
: the keys for which f
applied to the current value returns Some
are kept, and those for which it returns None
are discarded.
Example:
let h = Hashtbl.of_alist_exn (module Int) [(1, 4); (5, 6)] in Hashtbl.filter_map h ~f:(fun x -> if x > 5 then Some x else None) |> Hashtbl.to_alist;; - : (int * int) list = [(5, 6)]
Like filter_map
, but the function f
takes both key and data as arguments.
Returns new tables with bound values partitioned by f
applied to the bound values.
val partition_mapi : ('a, 'b) t -> f:(key:'a key -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'b) t * ('a, 'b) t
Like partition_map
, but the function f
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 the rest.
Like partition_tf
, but the function f
takes both key and data as arguments.
find_or_add t k ~default
returns the data associated with key k
if it is in the table t
, and otherwise assigns k
the value returned by default ()
.
Like find_or_add
but default
takes the key as an argument.
find t k
returns Some
(the current binding) of k
in t
, or None
if no such binding exists.
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.
val findi_and_call : ('a, 'b) t -> 'a key -> if_found:(key:'a key -> data:'b -> 'c) -> if_not_found:('a key -> 'c) -> 'c
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 : ('a, 'b) t -> ('a, 'b) t -> f:(key:'a key -> [ `Left of 'a | `Right of 'b | `Both of 'a * 'b ] -> 'c option) -> ('a, 'b) t
Merges 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) =
f ~key:k (`Left d1)
ifk
inh1
maps to d1, andh2
does not have data fork
;
f ~key:k (`Right d2)
ifk
inh2
maps to d2, andh1
does not have data fork
;
f ~key:k (`Both (d1, d2))
otherwise, wherek
inh1
maps tod1
andk
inh2
maps tod2
.
Each key k
is mapped to a single piece of data x
, where d(k) = Some x
.
Example:
let h1 = Hashtbl.of_alist_exn (module Int) [(1, 5); (2, 3232)] in let h2 = Hashtbl.of_alist_exn (module Int) [(1, 3)] in Hashtbl.merge h1 h2 ~f:(fun ~key:_ -> function | `Left x -> Some (`Left x) | `Right x -> Some (`Right x) | `Both (x, y) -> if x=y then None else Some (`Both (x,y)) ) |> Hashtbl.to_alist;; - : (int * [> `Both of int * int | `Left of int | `Right of int ]) list = [(2, `Left 3232); (1, `Both (5, 3))]
Every key
in src
will be removed or set in dst
according to the return value of f
.
val merge_into : src:('a, 'b) t -> dst:('a, 'b) t -> f:(key:'a key -> 'a -> 'b option -> 'b merge_into_action) -> unit
val data : ('a, 'b) t -> 'b list
Returns the list of all data for given hashtable.
filter_inplace t ~f
removes all the elements from t
that don't satisfy f
.
val filter_inplace : ('a, 'b) t -> f:('b -> bool) -> unit
val map_inplace : ('a, '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 : ('a, '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.
Returns the list of all (key, data) pairs for given hashtable.
val validate : name:('a key -> string) -> 'b Base.Validate.check -> ('a, 'b) t Base.Validate.check
remove_if_zero
's default is false
.
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.
remove_multi t key
updates the table, removing the head of the list bound to key
. If the list has only one element (or is empty) then the binding is removed.