Module type Hashtbl.Accessors
Accessors
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 -> [ `Fst of 'c | `Snd of 'd ]) -> ('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 -> [ `Fst of 'c | `Snd of 'd ]) -> ('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 findi_and_call : ('a, 'b) t -> 'a key -> if_found:(key:'a key -> data:'b -> 'c) -> if_not_found:('a key -> '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
.