# Module Std_kernel.Hashtbl_intf

    module Hashtbl_intf: Core_hashtbl_intf

    module Binable: Binable0

    module type Key = sig .. end

    module type Key_binable = sig .. end

    module Hashable: sig .. end

    module type Hashable = sig .. end

    type ('a, 'z) no_map_options = 'z

    module type Accessors = sig .. end

    type ('key, 'data, 'z) create_options_without_hashable = ?growth_allowed:bool -> ?size:int -> 'z

    type ('key, 'data, 'z) create_options_with_hashable = ?growth_allowed:bool ->
           ?size:int -> hashable:'key Hashable.t -> 'z

    module type Creators = sig .. end

    module type S = sig .. end

    module type S_binable = sig .. end

    module type Hashtbl = sig .. end

Values returned by `hash` must be non-negative. An exception will be raised in the case that `hash` returns a negative value.
`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).
`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.
`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.
`map t f` returns new table with bound values replaced by `f` applied to the bound values
like `map`, but function takes both key and data as arguments
returns new map with bound values filtered by f applied to the bound values
like `filter_map`, but function takes both key and data as arguments
returns new maps with bound values partitioned by f applied to the bound values
like `partition_map`, but function takes both key and data as arguments
`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.
`find t k` returns Some (the current binding) of k in t, or None if no such binding exists
`find_exn t k` returns the current binding of k in t, or raises Not_found if no such binding exists.
`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.
`find_and_remove t k` returns Some (the current binding) of k in t and removes it, or None is no such binding exists
`iter_vals t ~f` is like iter, except it only supplies the value to f, not the key.
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.
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`.
Returns the list of all keys for given hashtable.
Returns the list of all data for given hashtable.
`filter_inplace t ~f` removes all the elements from `t` that don't satisfy `f`.
`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.
Returns the list of all (key,data) pairs for given hashtable.
defaults to `true`
initial size -- default 128
defaults to `true`
initial size -- default 128

     create_mapped get_key get_data [x1,...,xn]
             = of_alist [get_key x1, get_data x1; ...; get_key xn, get_data xn]

     create_with_key ~get_key [x1,...,xn]
             = of_alist [get_key x1, x1; ...; get_key xn, xn]