Module type Core_hashtbl_intf.Access_sig.S

module type S = sig .. end

val clear : ('a, 'b) T.t -> unit

val copy : ('a, 'b) T.t -> ('a, 'b) T.t

val invariant : ('a, 'b) T.t -> unit

val fold : ('a, 'b) T.t ->
       init:'c -> f:(key:'a Core_hashtbl_intf.Key.t -> data:'b -> 'c -> 'c) -> 'c

val iter : ('a, 'b) T.t -> f:(key:'a Core_hashtbl_intf.Key.t -> data:'b -> unit) -> unit

val existsi : ('a, 'b) T.t -> f:(key:'a Core_hashtbl_intf.Key.t -> data:'b -> bool) -> bool

val exists : ('a, 'b) T.t -> f:('b -> bool) -> bool

val length : ('a, 'b) T.t -> int

val is_empty : ('a, 'b) T.t -> bool

val mem : ('a, 'b) T.t -> 'a Core_hashtbl_intf.Key.t -> bool

val remove : ('a, 'b) T.t -> 'a Core_hashtbl_intf.Key.t -> unit

val remove_one : ('a, 'b list) T.t -> 'a Core_hashtbl_intf.Key.t -> unit

val replace : ('a, 'b) T.t -> key:'a Core_hashtbl_intf.Key.t -> data:'b -> unit

val change : ('a, 'b) T.t ->
       'a Core_hashtbl_intf.Key.t -> ('b option -> 'b option) -> unit

change t key f updates the given table by changing the value stored under key according to f, just like Map.change (see that for example).

val add_multi : ('a, 'b list) T.t -> key:'a Core_hashtbl_intf.Key.t -> data:'b -> unit

val map : ('a, 'b) T.t -> f:('b -> 'c) -> ('a, 'c) T.t

map t f returns new table with bound values replaced by f applied to the bound values

val mapi : ('a, 'b) T.t ->
       f:(key:'a Core_hashtbl_intf.Key.t -> data:'b -> 'c) -> ('a, 'c) T.t

like map, but function takes both key and data as arguments

val filter_map : ('a, 'b) T.t -> f:('b -> 'c option) -> ('a, 'c) T.t

returns new map with bound values filtered by f applied to the bound values

val filter_mapi : ('a, 'b) T.t ->
       f:(key:'a Core_hashtbl_intf.Key.t -> data:'b -> 'c option) -> ('a, 'c) T.t

like filter_map, but function takes both key and data as arguments

val filter : ('a, 'b) T.t -> f:('b -> bool) -> ('a, 'b) T.t

val filteri : ('a, 'b) T.t ->
       f:(key:'a Core_hashtbl_intf.Key.t -> data:'b -> bool) -> ('a, 'b) T.t

val find_or_add : ('a, 'b) T.t -> 'a Core_hashtbl_intf.Key.t -> default:(unit -> 'b) -> 'b

find_or_add t k ~default returns the data associated with key k if it is in the table t, otherwise it lets d = default() and adds it to the table.

val find : ('a, 'b) T.t -> 'a Core_hashtbl_intf.Key.t -> 'b option

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

val find_exn : ('a, 'b) T.t -> 'a Core_hashtbl_intf.Key.t -> 'b

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

iter_vals t ~f is like iter, except it only supplies the value to f, not the key.

val iter_vals : ('a, 'b) T.t -> f:('b -> unit) -> unit

Merge 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 (Some d1) None if the *most recent* binding of k in h1 is to d1, and h2 does not map k;

f ~key:k None (Some d2) if the *most recent* binding of k in h2 is to d2, and h1 does not map k;

f ~key:k (Some d1) (Some d2) otherwise, where the *most recent* binding of k in h1 is to d1 and the *most recent* binding of k in h2 is to d2.

Each key k is mapped to a single piece of data x, where d(k) = Some x.

val merge : f:(key:'a Core_hashtbl_intf.Key.t -> 'b option -> 'c option -> 'd option) ->
       ('a, 'b) T.t -> ('a, 'c) T.t -> ('a, 'd) T.t

val merge_into : f:(key:'a Core_hashtbl_intf.Key.t -> 'b -> 'b option -> 'b option) ->
       src:('a, 'b) T.t -> dst:('a, 'b) T.t -> unit

Merge one hashtable into another.

After merge_into f src dst, for every key in src, key will be re-mapped in dst to v if f ~key d1 (find dst key) = Some v.

val keys : ('a, 'b) T.t -> 'a Core_hashtbl_intf.Key.t list

Returns the list of all unique keys for given hashtable. Keys bound multiple times will not be returned twice.

Returns the list of all data for given hashtable.

val data : ('a, 'b) T.t -> 'b list

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

val filter_inplace : ('a, 'b) T.t -> f:('b -> bool) -> unit

val filteri_inplace : ('a, 'b) T.t -> f:('a Core_hashtbl_intf.Key.t -> 'b -> bool) -> unit

val equal : ('a, 'b) T.t -> ('a, 'b) T.t -> ('b -> 'b -> bool) -> bool

val to_alist : ('a, 'b) T.t -> ('a Core_hashtbl_intf.Key.t * 'b) list

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

val incr : ?by:int -> ('a, int) T.t -> 'a Core_hashtbl_intf.Key.t -> unit