Module type Hashtbl.S_without_submodules
val sexp_of_t : ('a -> Base.Sexp.t) -> ('b -> Base.Sexp.t) -> ('a, 'b) t -> Base.Sexp.t
We provide a
sexp_of_t
but not at_of_sexp
for this type because one needs to be explicit about the hash and comparison functions used when creating a hashtable. Note thatHashtbl.Poly.t
does have[@@deriving sexp]
, and uses OCaml's built-in polymorphic comparison and and polymorphic hashing.
Creators
val create : ?growth_allowed:bool -> ?size:int -> 'a Base__.Hashtbl_intf.Key.t -> ('a, 'b) t
The module you pass to
create
must have a type that is hashable, sexpable, and comparable.Example:
Hashtbl.create (module Int);; - : (int, '_a) Hashtbl.t = <abstr>;;
val of_alist : ?growth_allowed:bool -> ?size:int -> 'a Base__.Hashtbl_intf.Key.t -> ('a * 'b) list -> [ `Ok of ('a, 'b) t | `Duplicate_key of 'a ]
Example:
Hashtbl.of_alist (module Int) [(3, "something"); (2, "whatever")] - : [ `Duplicate_key of int | `Ok of (int, string) Hashtbl.t ] = `Ok <abstr>
val of_alist_report_all_dups : ?growth_allowed:bool -> ?size:int -> 'a Base__.Hashtbl_intf.Key.t -> ('a * 'b) list -> [ `Ok of ('a, 'b) t | `Duplicate_keys of 'a list ]
Whereas
of_alist
will reportDuplicate_key
no matter how many dups there are in your list,of_alist_report_all_dups
will report each and every duplicate entry.For example:
Hashtbl.of_alist (module Int) [(1, "foo"); (1, "bar"); (2, "foo"); (2, "bar")];; - : [ `Duplicate_key of int | `Ok of (int, string) Hashtbl.t ] = `Duplicate_key 1 Hashtbl.of_alist_report_all_dups (module Int) [(1, "foo"); (1, "bar"); (2, "foo"); (2, "bar")];; - : [ `Duplicate_keys of int list | `Ok of (int, string) Hashtbl.t ] = `Duplicate_keys [1; 2]
val of_alist_or_error : ?growth_allowed:bool -> ?size:int -> 'a Base__.Hashtbl_intf.Key.t -> ('a * 'b) list -> ('a, 'b) t Base.Or_error.t
val of_alist_exn : ?growth_allowed:bool -> ?size:int -> 'a Base__.Hashtbl_intf.Key.t -> ('a * 'b) list -> ('a, 'b) t
val of_alist_multi : ?growth_allowed:bool -> ?size:int -> 'a Base__.Hashtbl_intf.Key.t -> ('a * 'b) list -> ('a, 'b list) t
Creates a "multi" hashtable, i.e., a hashtable where each key points to a list potentially containing multiple values. So instead of short-circuiting with a
`Duplicate_key
variant on duplicates, as inof_alist
,of_alist_multi
folds those values into a list for the given key:let h = Hashtbl.of_alist_multi (module Int) [(1, "a"); (1, "b"); (2, "c"); (2, "d")];; val h : (int, string list) Hashtbl.t = <abstr> Hashtbl.find_exn h 1;; - : string list = ["b"; "a"]
val create_mapped : ?growth_allowed:bool -> ?size:int -> 'a Base__.Hashtbl_intf.Key.t -> get_key:('r -> 'a) -> get_data:('r -> 'b) -> 'r list -> [ `Ok of ('a, 'b) t | `Duplicate_keys of 'a list ]
Applies the
get_key
andget_data
functions to the'r list
to create the initial keys and values, respectively, for the new hashtable.create_mapped get_key get_data [x1;...;xn] = of_alist [get_key x1, get_data x1; ...; get_key xn, get_data xn]
Example:
let h = Hashtbl.create_mapped (module Int) ~get_key:(fun x -> x) ~get_data:(fun x -> x + 1) [1; 2; 3];; val h : [ `Duplicate_keys of int list | `Ok of (int, int) Hashtbl.t ] = `Ok <abstr> let h = match h with | `Ok x -> x | `Duplicate_keys _ -> failwith "" in Hashtbl.find_exn h 1;; - : int = 2
val create_with_key : ?growth_allowed:bool -> ?size:int -> 'a Base__.Hashtbl_intf.Key.t -> get_key:('r -> 'a) -> 'r list -> [ `Ok of ('a, 'r) t | `Duplicate_keys of 'a list ]
create_with_key ~get_key [x1;...;xn] = of_alist [get_key x1, x1; ...; get_key xn, xn]
val create_with_key_or_error : ?growth_allowed:bool -> ?size:int -> 'a Base__.Hashtbl_intf.Key.t -> get_key:('r -> 'a) -> 'r list -> ('a, 'r) t Base.Or_error.t
val create_with_key_exn : ?growth_allowed:bool -> ?size:int -> 'a Base__.Hashtbl_intf.Key.t -> get_key:('r -> 'a) -> 'r list -> ('a, 'r) t
val group : ?growth_allowed:bool -> ?size:int -> 'a Base__.Hashtbl_intf.Key.t -> get_key:('r -> 'a) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t
Like
create_mapped
, applies theget_key
andget_data
functions to the'r list
to create the initial keys and values, respectively, for the new hashtable -- and then, likeadd_multi
, folds together values belonging to the same keys. Here, though, the function used for the folding is given bycombine
(instead of just being acons
).Example:
Hashtbl.group (module Int) ~get_key:(fun x -> x / 2) ~get_data:(fun x -> x) ~combine:(fun x y -> x * y) [ 1; 2; 3; 4] |> Hashtbl.to_alist;; - : (int * int) list = [(2, 4); (1, 6); (0, 1)]
val sexp_of_key : ('a, _) t -> 'a key -> Base.Sexp.t
val clear : (_, _) t -> unit
val copy : ('a, 'b) t -> ('a, 'b) t
val fold : ('a, 'b) t -> init:'c -> f:(key:'a key -> data:'b -> 'c -> 'c) -> 'c
Attempting to modify (
set
,remove
, etc.) the hashtable during iteration (fold
,iter
,iter_keys
,iteri
) will raise an exception.
val iter_keys : ('a, _) t -> f:('a key -> unit) -> unit
val iter : (_, 'b) t -> f:('b -> unit) -> unit
val iteri : ('a, 'b) t -> f:(key:'a key -> data:'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 existsi : ('a, 'b) t -> f:(key:'a key -> data:'b -> bool) -> bool
val exists : (_, 'b) t -> f:('b -> bool) -> bool
val for_alli : ('a, 'b) t -> f:(key:'a key -> data:'b -> bool) -> bool
val for_all : (_, 'b) t -> f:('b -> bool) -> bool
val counti : ('a, 'b) t -> f:(key:'a key -> data:'b -> bool) -> int
val count : (_, 'b) t -> f:('b -> bool) -> int
val length : (_, _) t -> int
val is_empty : (_, _) t -> bool
val mem : ('a, _) t -> 'a key -> bool
val remove : ('a, _) t -> 'a key -> unit
val choose : ('a, 'b) t -> ('a key * 'b) option
val choose_exn : ('a, 'b) t -> 'a key * 'b
val set : ('a, 'b) t -> key:'a key -> data:'b -> unit
Sets the given
key
todata
.
val add : ('a, 'b) t -> key:'a key -> data:'b -> [ `Ok | `Duplicate ]
add
andadd_exn
leave the table unchanged if the key was already present.
val add_exn : ('a, 'b) t -> key:'a key -> data:'b -> unit
val change : ('a, 'b) t -> 'a key -> f:('b option -> 'b option) -> unit
change t key ~f
changest
's value forkey
to bef (find t key)
.
val update : ('a, 'b) t -> 'a key -> f:('b option -> 'b) -> unit
update t key ~f
ischange t key ~f:(fun o -> Some (f o))
.
val map : ('a, 'b) t -> f:('b -> 'c) -> ('a, 'c) t
map t f
returns a new table with values replaced by the result of applyingf
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)]
val mapi : ('a, 'b) t -> f:(key:'a key -> data:'b -> 'c) -> ('a, 'c) t
Like
map
, but the functionf
takes both key and data as arguments.
val filter_map : ('a, 'b) t -> f:('b -> 'c option) -> ('a, 'c) t
Returns a new table by filtering the given table's values by
f
: the keys for whichf
applied to the current value returnsSome
are kept, and those for which it returnsNone
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)]
val filter_mapi : ('a, 'b) t -> f:(key:'a key -> data:'b -> 'c option) -> ('a, 'c) t
Like
filter_map
, but the functionf
takes both key and data as arguments.
val filter_keys : ('a, 'b) t -> f:('a key -> bool) -> ('a, 'b) t
val filter : ('a, 'b) t -> f:('b -> bool) -> ('a, 'b) t
val filteri : ('a, 'b) t -> f:(key:'a key -> data:'b -> bool) -> ('a, 'b) t
val partition_map : ('a, 'b) t -> f:('b -> ('c, 'd) Base.Either.t) -> ('a, 'c) t * ('a, 'd) 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 -> ('c, 'd) Base.Either.t) -> ('a, 'c) t * ('a, 'd) t
Like
partition_map
, but the functionf
takes both key and data as arguments.
val partition_tf : ('a, 'b) t -> f:('b -> bool) -> ('a, 'b) t * ('a, 'b) t
Returns a pair of tables
(t1, t2)
, wheret1
contains all the elements of the initial table which satisfy the predicatef
, andt2
contains the rest.
val partitioni_tf : ('a, 'b) t -> f:(key:'a key -> data:'b -> bool) -> ('a, 'b) t * ('a, 'b) t
Like
partition_tf
, but the functionf
takes both key and data as arguments.
val find_or_add : ('a, 'b) t -> 'a key -> default:(unit -> 'b) -> 'b
find_or_add t k ~default
returns the data associated with keyk
if it is in the tablet
, and otherwise assignsk
the value returned bydefault ()
.
val findi_or_add : ('a, 'b) t -> 'a key -> default:('a key -> 'b) -> 'b
Like
find_or_add
butdefault
takes the key as an argument.
val find : ('a, 'b) t -> 'a key -> 'b option
find t k
returnsSome
(the current binding) ofk
int
, orNone
if no such binding exists.
val find_exn : ('a, 'b) t -> 'a key -> 'b
find_exn t k
returns the current binding ofk
int
, or raisesCaml.Not_found
orNot_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 find_and_call1 : ('a, 'b) t -> 'a key -> a:'d -> if_found:('b -> 'd -> 'c) -> if_not_found:('a key -> 'd -> 'c) -> 'c
Just like
find_and_call
, but takes an extra argument which is passed toif_found
andif_not_found
, so that the client code can avoid allocating closures or using refs to pass this additional information. This function is only useful in code which tries to minimize heap allocation.
val find_and_call2 : ('a, 'b) t -> 'a key -> a:'d -> b:'e -> if_found:('b -> 'd -> 'e -> 'c) -> if_not_found:('a key -> 'd -> 'e -> 'c) -> 'c
val findi_and_call : ('a, 'b) t -> 'a key -> if_found:(key:'a key -> data:'b -> 'c) -> if_not_found:('a key -> 'c) -> 'c
val findi_and_call1 : ('a, 'b) t -> 'a key -> a:'d -> if_found:(key:'a key -> data:'b -> 'd -> 'c) -> if_not_found:('a key -> 'd -> 'c) -> 'c
val findi_and_call2 : ('a, 'b) t -> 'a key -> a:'d -> b:'e -> if_found:(key:'a key -> data:'b -> 'd -> 'e -> 'c) -> if_not_found:('a key -> 'd -> 'e -> 'c) -> 'c
val find_and_remove : ('a, 'b) t -> 'a key -> 'b 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
Merges two hashtables.
The result of
merge f h1 h2
has as keys the set of allk
in the union of the sets of keys ofh1
andh2
for whichd(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 datax
, whered(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))]
val merge_into : src:('k, 'a) t -> dst:('k, 'b) t -> f:(key:'k key -> 'a -> 'b option -> 'b Base__.Hashtbl_intf.Merge_into_action.t) -> unit
Every
key
insrc
will be removed or set indst
according to the return value off
.
val data : (_, 'b) t -> 'b list
Returns the list of all data for given hashtable.
val filter_keys_inplace : ('a, _) t -> f:('a key -> bool) -> unit
filter_inplace t ~f
removes all the elements fromt
that don't satisfyf
.
val filter_inplace : (_, 'b) t -> f:('b -> bool) -> unit
val filteri_inplace : ('a, 'b) t -> f:(key:'a key -> data:'b -> bool) -> unit
val map_inplace : (_, 'b) t -> f:('b -> 'b) -> unit
map_inplace t ~f
appliesf
to all elements int
, transforming them in place.
val mapi_inplace : ('a, 'b) t -> f:(key:'a key -> data:'b -> 'b) -> unit
val filter_map_inplace : (_, 'b) t -> f:('b -> 'b option) -> unit
filter_map_inplace
combines the effects ofmap_inplace
andfilter_inplace
.
val filter_mapi_inplace : ('a, 'b) t -> f:(key:'a key -> data:'b -> 'b option) -> unit
val equal : ('b -> 'b -> bool) -> ('a, 'b) t -> ('a, 'b) t -> bool
equal f t1 t2
andsimilar f t1 t2
both return true ifft1
andt2
have the same keys and for all keysk
,f (find_exn t1 k) (find_exn t2 k)
.equal
andsimilar
only differ in their types.
val similar : ('b1 -> 'b2 -> bool) -> ('a, 'b1) t -> ('a, 'b2) t -> bool
val to_alist : ('a, 'b) t -> ('a key * 'b) list
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
val incr : ?by:int -> ?remove_if_zero:bool -> ('a, int) t -> 'a key -> unit
remove_if_zero
's default isfalse
.
val add_multi : ('a, 'b list) t -> key:'a key -> data:'b -> unit
add_multi t ~key ~data
ifkey
is present in the table then consdata
on the list, otherwise addkey
with a single element list.
val hashable_s : ('key, _) t -> 'key Base__.Hashtbl_intf.Key.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