package base

  1. Overview
  2. Docs
On This Page
  1. Accessors
package base
Legend:
Page
Library
Module
Module type
Parameter
Class
Class type
Source

Module Hashtbl.PolySource

Sourcetype ('a, 'b) t = ('a, 'b) t
include Sexplib0.Sexpable.S2 with type ('a, 'b) t := ('a, 'b) t
Sourceval t_of_sexp : (Sexplib0.Sexp.t -> 'a) -> (Sexplib0.Sexp.t -> 'b) -> Sexplib0.Sexp.t -> ('a, 'b) t
Sourceval sexp_of_t : ('a -> Sexplib0.Sexp.t) -> ('b -> Sexplib0.Sexp.t) -> ('a, 'b) t -> Sexplib0.Sexp.t
Sourceval hashable : 'a Hashable.t
include Invariant.S2 with type ('a, 'b) t := ('a, 'b) t
Sourceval invariant : ('a -> unit) -> ('b -> unit) -> ('a, 'b) t -> unit
Sourcetype 'a key = 'a
Sourceval create : ?growth_allowed:bool -> ?size:int -> unit -> ('a, 'b) t
Sourceval of_alist : ?growth_allowed:bool -> ?size:int -> ('a key * 'b) list -> [ `Ok of ('a, 'b) t | `Duplicate_key of 'a key ]
Sourceval of_alist_report_all_dups : ?growth_allowed:bool -> ?size:int -> ('a key * 'b) list -> [ `Ok of ('a, 'b) t | `Duplicate_keys of 'a key list ]
Sourceval of_alist_or_error : ?growth_allowed:bool -> ?size:int -> ('a key * 'b) list -> ('a, 'b) t Or_error.t
Sourceval of_alist_exn : ?growth_allowed:bool -> ?size:int -> ('a key * 'b) list -> ('a, 'b) t
Sourceval of_alist_multi : ?growth_allowed:bool -> ?size:int -> ('a key * 'b) list -> ('a, 'b list) t
Sourceval create_mapped : ?growth_allowed:bool -> ?size:int -> get_key:('r -> 'a key) -> get_data:('r -> 'b) -> 'r list -> [ `Ok of ('a, 'b) t | `Duplicate_keys of 'a key list ]
 create_mapped get_key get_data [x1,...,xn]
   = of_alist [get_key x1, get_data x1; ...; get_key xn, get_data xn]
Sourceval create_with_key : ?growth_allowed:bool -> ?size:int -> get_key:('r -> 'a key) -> 'r list -> [ `Ok of ('a, 'r) t | `Duplicate_keys of 'a key list ]
 create_with_key ~get_key [x1,...,xn]
   = of_alist [get_key x1, x1; ...; get_key xn, xn]
Sourceval create_with_key_or_error : ?growth_allowed:bool -> ?size:int -> get_key:('r -> 'a key) -> 'r list -> ('a, 'r) t Or_error.t
Sourceval create_with_key_exn : ?growth_allowed:bool -> ?size:int -> get_key:('r -> 'a key) -> 'r list -> ('a, 'r) t
Sourceval group : ?growth_allowed:bool -> ?size:int -> get_key:('r -> 'a key) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t

Accessors

Sourceval sexp_of_key : ('a, _) t -> 'a key -> Sexp.t
Sourceval clear : (_, _) t -> unit
Sourceval copy : ('a, 'b) t -> ('a, 'b) t
Sourceval fold : ('a, 'b) t -> init:'acc -> f:(key:'a key -> data:'b -> 'acc -> 'acc) -> 'acc

Attempting to modify (set, remove, etc.) the hashtable during iteration (fold, iter, iter_keys, iteri) will raise an exception.

Sourceval iter_keys : ('a, _) t -> f:('a key -> unit) -> unit
Sourceval iter : (_, 'b) t -> f:('b -> unit) -> unit
Sourceval 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 = ()
Sourceval existsi : ('a, 'b) t -> f:(key:'a key -> data:'b -> bool) -> bool
Sourceval exists : (_, 'b) t -> f:('b -> bool) -> bool
Sourceval for_alli : ('a, 'b) t -> f:(key:'a key -> data:'b -> bool) -> bool
Sourceval for_all : (_, 'b) t -> f:('b -> bool) -> bool
Sourceval counti : ('a, 'b) t -> f:(key:'a key -> data:'b -> bool) -> int
Sourceval count : (_, 'b) t -> f:('b -> bool) -> int
Sourceval length : (_, _) t -> int
Sourceval is_empty : (_, _) t -> bool
Sourceval mem : ('a, _) t -> 'a key -> bool
Sourceval remove : ('a, _) t -> 'a key -> unit
Sourceval choose : ('a, 'b) t -> ('a key * 'b) option

Choose an arbitrary key/value pair of a hash table. Returns None if t is empty.

The choice is deterministic. Calling choose multiple times on the same table returns the same key/value pair, so long as the table is not mutated in between. Beyond determinism, no guarantees are made about how the choice is made. Expect bias toward certain hash values.

This hash bias can lead to degenerate performance in some cases, such as clearing a hash table using repeated choose and remove. At each iteration, finding the next element may have to scan farther from its initial hash value.

Sourceval choose_exn : ('a, 'b) t -> 'a key * 'b

Like choose. Raises if t is empty.

Sourceval choose_randomly : ?random_state:Random.State.t -> ('a, 'b) t -> ('a key * 'b) option

Chooses a random key/value pair of a hash table. Returns None if t is empty.

The choice is distributed uniformly across hash values, rather than across keys themselves. As a consequence, the closer the keys are to evenly spaced out in the table, the closer this function will be to a uniform choice of keys.

This function may be preferable to choose when nondeterministic choice is acceptable, and bias toward certain hash values is undesirable.

Sourceval choose_randomly_exn : ?random_state:Random.State.t -> ('a, 'b) t -> 'a key * 'b

Like choose_randomly. Raises if t is empty.

Sourceval set : ('a, 'b) t -> key:'a key -> data:'b -> unit

Sets the given key to data.

Sourceval add : ('a, 'b) t -> key:'a key -> data:'b -> [ `Ok | `Duplicate ]

add and add_exn leave the table unchanged if the key was already present.

Sourceval add_exn : ('a, 'b) t -> key:'a key -> data:'b -> unit
Sourceval change : ('a, 'b) t -> 'a key -> f:('b option -> 'b option) -> unit

change t key ~f changes t's value for key to be f (find t key).

Sourceval update : ('a, 'b) t -> 'a key -> f:('b option -> 'b) -> unit

update t key ~f is change t key ~f:(fun o -> Some (f o)).

Sourceval update_and_return : ('a, 'b) t -> 'a key -> f:('b option -> 'b) -> 'b

update_and_return t key ~f is update, but returns the result of f o.

Sourceval map : ('a, 'b) t -> f:('b -> 'c) -> ('a, 'c) t

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)[@local]) in
Hashtbl.to_alist h';;
- : (int * int) list = [(5, 12); (1, 8)]
Sourceval mapi : ('a, 'b) t -> f:(key:'a key -> data:'b -> 'c) -> ('a, 'c) t

Like map, but the function f takes both key and data as arguments.

Sourceval 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 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)[@local])
|> Hashtbl.to_alist;;
- : (int * int) list = [(5, 6)]
Sourceval filter_mapi : ('a, 'b) t -> f:(key:'a key -> data:'b -> 'c option) -> ('a, 'c) t

Like filter_map, but the function f takes both key and data as arguments.

Sourceval filter_keys : ('a, 'b) t -> f:('a key -> bool) -> ('a, 'b) t
Sourceval filter : ('a, 'b) t -> f:('b -> bool) -> ('a, 'b) t
Sourceval filteri : ('a, 'b) t -> f:(key:'a key -> data:'b -> bool) -> ('a, 'b) t
Sourceval partition_map : ('a, 'b) t -> f:('b -> ('c, 'd) Either.t) -> ('a, 'c) t * ('a, 'd) t

Returns new tables with bound values partitioned by f applied to the bound values.

Sourceval partition_mapi : ('a, 'b) t -> f:(key:'a key -> data:'b -> ('c, 'd) Either.t) -> ('a, 'c) t * ('a, 'd) t

Like partition_map, but the function f takes both key and data as arguments.

Sourceval partition_tf : ('a, 'b) t -> f:('b -> bool) -> ('a, 'b) t * ('a, 'b) t

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.

Sourceval partitioni_tf : ('a, 'b) t -> f:(key:'a key -> data:'b -> bool) -> ('a, 'b) t * ('a, 'b) t

Like partition_tf, but the function f takes both key and data as arguments.

Sourceval find_or_add : ('a, 'b) t -> 'a key -> default:(unit -> 'b) -> 'b

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 ().

Sourceval findi_or_add : ('a, 'b) t -> 'a key -> default:('a key -> 'b) -> 'b

Like find_or_add but default takes the key as an argument.

Sourceval find : ('a, 'b) t -> 'a key -> 'b option

find t k returns Some (the current binding) of k in t, or None if no such binding exists.

Sourceval find_exn : ('a, 'b) t -> 'a key -> 'b

find_exn t k returns the current binding of k in t, or raises Stdlib.Not_found or Not_found_s if no such binding exists.

Sourceval 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.

Sourceval 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 to if_found and if_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.

Sourceval 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
Sourceval findi_and_call : ('a, 'b) t -> 'a key -> if_found:(key:'a key -> data:'b -> 'c) -> if_not_found:('a key -> 'c) -> 'c
Sourceval 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
Sourceval 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
Sourceval 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.

Sourceval 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 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) if k in h1 maps to d1, and h2 does not have data for k;
  • f ~key:k (`Right d2) if k in h2 maps to d2, and h1 does not have data for k;
  • f ~key:k (`Both (d1, d2)) otherwise, where k in h1 maps to d1 and k in h2 maps to d2.

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))]
Sourceval merge_into : src:('k, 'a) t -> dst:('k, 'b) t -> f:(key:'k key -> 'a -> 'b option -> 'b Merge_into_action.t) -> unit

Every key in src will be removed or set in dst according to the return value of f.

Sourceval keys : ('a, _) t -> 'a key list

Returns the list of all keys for given hashtable.

Sourceval data : (_, 'b) t -> 'b list

Returns the list of all data for given hashtable.

Sourceval filter_keys_inplace : ('a, _) t -> f:('a key -> bool) -> unit

filter_inplace t ~f removes all the elements from t that don't satisfy f.

Sourceval filter_inplace : (_, 'b) t -> f:('b -> bool) -> unit
Sourceval filteri_inplace : ('a, 'b) t -> f:(key:'a key -> data:'b -> bool) -> unit
Sourceval map_inplace : (_, 'b) t -> f:('b -> 'b) -> unit

map_inplace t ~f applies f to all elements in t, transforming them in place.

Sourceval mapi_inplace : ('a, 'b) t -> f:(key:'a key -> data:'b -> 'b) -> unit
Sourceval filter_map_inplace : (_, 'b) t -> f:('b -> 'b option) -> unit

filter_map_inplace combines the effects of map_inplace and filter_inplace.

Sourceval filter_mapi_inplace : ('a, 'b) t -> f:(key:'a key -> data:'b -> 'b option) -> unit
Sourceval equal : ('b -> 'b -> bool) -> ('a, 'b) t -> ('a, 'b) t -> bool

equal f t1 t2 and similar f t1 t2 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.

Sourceval similar : ('b1 -> 'b2 -> bool) -> ('a, 'b1) t -> ('a, 'b2) t -> bool
Sourceval to_alist : ('a, 'b) t -> ('a key * 'b) list

Returns the list of all (key, data) pairs for given hashtable.

Sourceval incr : ?by:int -> ?remove_if_zero:bool -> ('a, int) t -> 'a key -> unit

remove_if_zero's default is false.

Sourceval decr : ?by:int -> ?remove_if_zero:bool -> ('a, int) t -> 'a key -> unit
Sourceval add_multi : ('a, 'b list) t -> key:'a key -> data:'b -> unit

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.

Sourceval remove_multi : ('a, _ list) t -> 'a key -> unit

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.

Sourceval find_multi : ('a, 'b list) t -> 'a key -> 'b list

find_multi t key returns the empty list if key is not present in the table, returns t's values for key otherwise.

OCaml

Innovation. Community. Security.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events OCaml Planet Jobs
Resources
Install OCaml Get Started Platform Tools Language Manual Standard Library API Books Exercises Papers OCaml Playground Logo
Policies
Carbon Footprint Governance Privacy Code of Conduct