include Hashtbl_intf.S with type ('a, 'b) hashtbl = ('a, 'b) Hashtbl.t with type key = t
include Hashtbl_intf.S_plain with type ('a, 'b) hashtbl = ('a, 'b) Hashtbl.t with type key = t
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Hashtbl.t
val sexp_of_t : ('b -> Ppx_sexp_conv_lib.Sexp.t) -> 'b t -> Ppx_sexp_conv_lib.Sexp.t
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Hashtbl_intf.Hashable.t
include Base.Invariant.S1 with type 'b t := 'b t
val invariant : ('a -> unit) -> 'b t -> unit
include Hashtbl_intf.Creators with type ('a, 'b) t := ('a, 'b) t_ with type 'a key := 'a key_ with type ('key, 'data, 'z) create_options := ('key, 'data, 'z) Hashtbl_intf.create_options_without_hashable
val create : ('key, 'data, 'z) Hashtbl_intf.create_options_without_hashable
val of_alist : ('key, 'data, 'z) Hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups : ('key, 'data, 'z) Hashtbl_intf.create_options_without_hashable
val of_alist_or_error : ('key, 'data, 'z) Hashtbl_intf.create_options_without_hashable
val of_alist_exn : ('key, 'data, 'z) Hashtbl_intf.create_options_without_hashable
val of_alist_multi : ('key, 'data, 'z) Hashtbl_intf.create_options_without_hashable
val create_mapped : ('key, 'data, 'z) Hashtbl_intf.create_options_without_hashable
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 : ('key, 'data, 'z) Hashtbl_intf.create_options_without_hashable
create_with_key ~get_key [x1,...,xn]
= of_alist [get_key x1, x1; ...; get_key xn, xn]
val create_with_key_or_error : ('key, 'data, 'z) Hashtbl_intf.create_options_without_hashable
val create_with_key_exn : ('key, 'data, 'z) Hashtbl_intf.create_options_without_hashable
val group : ('key, 'data, 'z) Hashtbl_intf.create_options_without_hashable
include Hashtbl_intf.Accessors with type ('a, 'b) t := ('a, 'b) t_ with type 'a key := 'a key_
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.
val partition_map : ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'b) t_ * ('a, 'b) t_
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
.
include 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.
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.
module Provide_of_sexp : functor (Key : sig ... end with type Provide_of_sexp.t := key) -> sig ... end with type 'a Provide_of_sexp.t := 'a t
module Provide_bin_io : functor (Key : sig ... end with type Provide_bin_io.t := key) -> sig ... end with type 'a Provide_bin_io.t := 'a t
include sig ... end with type 'a Table.t := 'a t
val t_of_sexp : (Ppx_sexp_conv_lib.Sexp.t -> 'v_x__002_) -> Ppx_sexp_conv_lib.Sexp.t -> 'a t
include Hashtbl_intf.Binable.S1 with type 'v t := 'v t
val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
val bin_size_t : ('a, 'v t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'v t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'v t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'v t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'v t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'v t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'v t) Bin_prot.Type_class.S1.t