# Module type Core_hashtbl_intf.Accessors

    module type Accessors = sig .. end

    type ('a, 'b) t

    type 'a key

    type ('a, 'z) map_options

    val sexp_of_key : ('a, 'b) t ->
           'a key -> Sexplib.Sexp.t

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

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

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

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

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

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

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

    val for_alli : ('a, 'b) t ->
           f:(key:'a key -> data:'b -> bool) -> bool

    val for_all : ('a, 'b) t -> f:('b -> bool) -> bool

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

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

    val mem : ('a, 'b) t ->
           'a key -> bool

    val remove : ('a, 'b) t ->
           'a key -> unit

    val remove_one : ('a, 'b list) t ->
           'a key -> unit

    val replace : ('a, 'b) t ->
           key:'a key -> data:'b -> unit

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

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

    val add_or_error : ('a, 'b) t ->
           key:'a key -> data:'b -> unit Or_error.t

    val add_exn : ('a, 'b) t ->
           key:'a key -> data:'b -> unit

    val change : ('a, 'b) t ->
           'a key -> ('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 ->
           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.

    val remove_multi : ('a, 'b 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.

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

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

    val mapi : ('c,
            ('a, 'b) t ->
            f:(key:'a key -> data:'b -> 'c) ->
            ('a, 'c) t)
           map_options

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

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

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

    val filter_mapi : ('c,
            ('a, 'b) t ->
            f:(key:'a key -> data:'b -> 'c option) ->
            ('a, 'c) t)
           map_options

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

    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 : ('c,
            ('d,
             ('a, 'b) t ->
             f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
             ('a, 'c) t *
             ('a, 'd) t)
            map_options)
           map_options

returns new maps with bound values partitioned by f applied to the bound values

    val partition_mapi : ('c,
            ('d,
             ('a, 'b) t ->
             f:(key:'a key ->
                data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
             ('a, 'c) t *
             ('a, 'd) t)
            map_options)
           map_options

like `partition_map`, but function takes both key and data as arguments

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

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

    val 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, otherwise it lets d = default() and adds it to the table.

    val 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

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

`find_exn t k` returns the current binding of k in t, or raises Not_found 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_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 iter_vals : ('a, 'b) t -> f:('b -> unit) -> unit

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

    val merge : ('c,
            ('k, 'a) t ->
            ('k, 'b) t ->
            f:(key:'k key ->
               [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
            ('k, 'c) t)
           map_options

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 `k` in `h1` is to d1, and `h2` does not map `k`;

- f ~key:k None (Some d2) if `k` in `h2` is to d2, and `h1` does not map `k`;

- f ~key:k (Some d1) (Some d2) otherwise, where `k` in `h1` is to `d1` and `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_into : f:(key:'a key -> 'b -> 'c option -> 'c option) ->
           src:('a, 'b) t ->
           dst:('a, 'c) 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 ->
           'a key list

Returns the list of all keys for given hashtable.

Returns the list of all data for given hashtable.

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

`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 filteri_inplace : ('a, 'b) t ->
           f:('a key -> 'b -> bool) -> unit

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

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

    val similar : ('a, 'b1) t ->
           ('a, 'b2) t -> ('b1 -> 'b2 -> bool) -> 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 Validate.check -> ('a, 'b) t Validate.check

    val incr : ?by:int ->
           ('a, int) t ->
           'a key -> unit