`include Core_kernel.Hashtbl_intf.S_plain`
`type key`````
`type ('a, 'b) hashtbl`````
`type 'b t``= (key, 'b) hashtbl```
`include sig ... end`
`val sexp_of_t : ('b ‑> Base.Sexp.t) ‑> 'b t ‑> Base.Sexp.t`
`type ('a, 'b) t_``= 'b t```
`type 'a key_``= key```
`val hashable : key Core_kernel.Hashtbl_intf.Hashable.t`
`include Core_kernel__.Import.Invariant.S1 with type b t := b t`
`type 'a t`````
`val invariant : 'a Base__.Invariant_intf.inv ‑> 'a t Base__.Invariant_intf.inv`
`include Core_kernel.Hashtbl_intf.Creators with type (a, b) t := (a, b) t_ with type a key := a key_ with type (key, data, z) create_options := (key, data, z) Core_kernel.Hashtbl_intf.create_options_without_hashable`
`val create : ('a key_, 'b, unit ‑> ('a, 'b) t_) Core_kernel.Hashtbl_intf.create_options_without_hashable`
`val of_alist : ('a key_, 'b, ('a key_ * 'b) list ‑> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Hashtbl_intf.create_options_without_hashable`
`val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list ‑> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Hashtbl_intf.create_options_without_hashable`
`val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list ‑> ('a, 'b) t_ Base.Or_error.t) Core_kernel.Hashtbl_intf.create_options_without_hashable`
`val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list ‑> ('a, 'b) t_) Core_kernel.Hashtbl_intf.create_options_without_hashable`
`val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list ‑> ('a, 'b list) t_) Core_kernel.Hashtbl_intf.create_options_without_hashable`
`val create_mapped : ('a key_, 'b, get_key:('r ‑> 'a key_) ‑> get_data:('r ‑> 'b) ‑> 'r list ‑> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Hashtbl_intf.create_options_without_hashable`
`val create_with_key : ('a key_, 'r, get_key:('r ‑> 'a key_) ‑> 'r list ‑> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Hashtbl_intf.create_options_without_hashable`
`val create_with_key_or_error : ('a key_, 'r, get_key:('r ‑> 'a key_) ‑> 'r list ‑> ('a, 'r) t_ Base.Or_error.t) Core_kernel.Hashtbl_intf.create_options_without_hashable`
`val create_with_key_exn : ('a key_, 'r, get_key:('r ‑> 'a key_) ‑> 'r list ‑> ('a, 'r) t_) Core_kernel.Hashtbl_intf.create_options_without_hashable`
`val group : ('a key_, 'b, get_key:('r ‑> 'a key_) ‑> get_data:('r ‑> 'b) ‑> combine:('b ‑> 'b ‑> 'b) ‑> 'r list ‑> ('a, 'b) t_) Core_kernel.Hashtbl_intf.create_options_without_hashable`
`include Core_kernel.Hashtbl_intf.Accessors with type (a, b) t := (a, b) t_ with type a key := a key_`
`val sexp_of_key : ('a, 'b) t_ ‑> 'a key_ ‑> Base.Sexp.t`
`val clear : ('a, 'b) 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`
`val iter_keys : ('a, 'b) t_ ‑> f:('a key_ ‑> unit) ‑> unit`
`val iter : ('a, 'b) t_ ‑> f:('b ‑> unit) ‑> unit`
`val iteri : ('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 counti : ('a, 'b) t_ ‑> f:(key:'a key_ ‑> data:'b ‑> bool) ‑> int`
`val count : ('a, 'b) t_ ‑> f:('b ‑> bool) ‑> int`
`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 set : ('a, 'b) t_ ‑> key:'a key_ ‑> data:'b ‑> unit`
`val add : ('a, 'b) t_ ‑> key:'a key_ ‑> data:'b ‑> [ `Duplicate | `Ok ]`
`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`
`val update : ('a, 'b) t_ ‑> 'a key_ ‑> f:('b option ‑> 'b) ‑> unit`
`val map : ('a, 'b) t_ ‑> f:('b ‑> 'c) ‑> ('a, 'c) t_`
`val mapi : ('a, 'b) t_ ‑> f:(key:'a key_ ‑> data:'b ‑> 'c) ‑> ('a, 'c) t_`
`val filter_map : ('a, 'b) t_ ‑> f:('b ‑> 'c option) ‑> ('a, 'c) t_`
`val filter_mapi : ('a, 'b) t_ ‑> f:(key:'a key_ ‑> data:'b ‑> 'c option) ‑> ('a, 'c) t_`
`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_`
`val partition_mapi : ('a, 'b) t_ ‑> f:(key:'a key_ ‑> data:'b ‑> [ `Fst of 'c | `Snd of 'd ]) ‑> ('a, 'c) t_ * ('a, 'd) t_`
`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`
`val findi_or_add : ('a, 'b) t_ ‑> 'a key_ ‑> default:('a key_ ‑> 'b) ‑> 'b`
`val find : ('a, 'b) t_ ‑> 'a key_ ‑> 'b option`
`val find_exn : ('a, 'b) t_ ‑> 'a key_ ‑> 'b`
`val find_and_call : ('a, 'b) t_ ‑> 'a key_ ‑> if_found:('b ‑> 'c) ‑> if_not_found:('a key_ ‑> 'c) ‑> 'c`
`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`
`val merge : ('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_`
`type 'a merge_into_action````=`

`|` `Remove`
`|` `Set_to of 'a`

``
`val merge_into : src:('k, 'a) t_ ‑> dst:('k, 'b) t_ ‑> f:(key:'k key_ ‑> 'a ‑> 'b option ‑> 'b merge_into_action) ‑> unit`
`val keys : ('a, 'b) t_ ‑> 'a key_ list`
`val data : ('a, 'b) t_ ‑> 'b list`
`val filter_keys_inplace : ('a, 'b) t_ ‑> f:('a key_ ‑> bool) ‑> unit`
`val filter_inplace : ('a, 'b) t_ ‑> f:('b ‑> bool) ‑> unit`
`val filteri_inplace : ('a, 'b) t_ ‑> f:(key:'a key_ ‑> data:'b ‑> bool) ‑> unit`
`val map_inplace : ('a, 'b) t_ ‑> f:('b ‑> 'b) ‑> unit`
`val mapi_inplace : ('a, 'b) t_ ‑> f:(key:'a key_ ‑> data:'b ‑> 'b) ‑> unit`
`val filter_map_inplace : ('a, 'b) t_ ‑> f:('b ‑> 'b option) ‑> unit`
`val filter_mapi_inplace : ('a, 'b) t_ ‑> f:(key:'a key_ ‑> data:'b ‑> 'b option) ‑> unit`
`val equal : ('a, 'b) t_ ‑> ('a, 'b) t_ ‑> ('b ‑> 'b ‑> bool) ‑> bool`
`val similar : ('a, 'b1) t_ ‑> ('a, 'b2) t_ ‑> ('b1 ‑> 'b2 ‑> bool) ‑> bool`
`val to_alist : ('a, 'b) t_ ‑> ('a key_ * 'b) list`
`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`
`val decr : ?⁠by:int ‑> ?⁠remove_if_zero:bool ‑> ('a, int) t_ ‑> 'a key_ ‑> unit`
`include Core_kernel.Hashtbl_intf.Multi with type (a, b) t := (a, b) t_ with type a key := a key_`
`val add_multi : ('a, 'b list) t_ ‑> key:'a key_ ‑> data:'b ‑> unit`
`val remove_multi : ('a, 'b list) t_ ‑> 'a key_ ‑> unit`
`val find_multi : ('a, 'b list) t_ ‑> 'a key_ ‑> 'b list`
`module Provide_of_sexp : functor (Key : sig ... end with type t := key) -> sig ... end with type a t := a t`
`module Provide_bin_io : functor (Key : sig ... end with type t := key) -> sig ... end with type a t := a t`
`include sig ... end with type a t := a t`
`type _ t`````
`include sig ... end`
`val t_of_sexp : (Base.Sexp.t ‑> 'v_x__002_) ‑> Base.Sexp.t ‑> 'v_x__002_ t`