sig
  module Hashable :
    sig
      type 'a t =
        'a Core_kernel.Core_hashtbl_intf.Hashable.t = {
        hash : 'a -> int;
        compare : 'a -> 'a -> int;
        sexp_of_t : 'a -> Sexplib.Sexp.t;
      }
      val poly : 'a t
      val of_key :
        (module Core_kernel.Core_hashtbl_intf.Key with type t = 'a) -> 'a t
      val hash_param : int -> int -> 'a -> int
      val hash : 'a -> int
    end
  val hash : 'a -> int
  val hash_param : int -> int -> 'a -> int
  type ('a, 'b) t = ('a, 'b) Core_kernel.Core_hashtbl.t
  type 'a key = 'a
  val create :
    ('a key, unit -> ('a, 'b) t)
    Core_kernel.Core_hashtbl_intf.create_options_with_hashable
  val of_alist :
    ('a key,
     ('a key * 'b) list -> [ `Duplicate_key of 'a key | `Ok of ('a, 'b) t ])
    Core_kernel.Core_hashtbl_intf.create_options_with_hashable
  val of_alist_report_all_dups :
    ('a key,
     ('a key * 'b) list ->
     [ `Duplicate_keys of 'a key list | `Ok of ('a, 'b) t ])
    Core_kernel.Core_hashtbl_intf.create_options_with_hashable
  val of_alist_exn :
    ('a key, ('a key * 'b) list -> ('a, 'b) t)
    Core_kernel.Core_hashtbl_intf.create_options_with_hashable
  val of_alist_multi :
    ('a key, ('a key * 'b) list -> ('a, 'b list) t)
    Core_kernel.Core_hashtbl_intf.create_options_with_hashable
  val create_mapped :
    ('a key,
     get_key:('r -> 'a key) ->
     get_data:('r -> 'b) ->
     'r list -> [ `Duplicate_keys of 'a key list | `Ok of ('a, 'b) t ])
    Core_kernel.Core_hashtbl_intf.create_options_with_hashable
  val create_with_key :
    ('a key,
     get_key:('r -> 'a key) ->
     'r list -> [ `Duplicate_keys of 'a key list | `Ok of ('a, 'r) t ])
    Core_kernel.Core_hashtbl_intf.create_options_with_hashable
  val create_with_key_exn :
    ('a key, get_key:('r -> 'a key) -> 'r list -> ('a, 'r) t)
    Core_kernel.Core_hashtbl_intf.create_options_with_hashable
  val group :
    ('a key,
     get_key:('r -> 'a key) ->
     get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t)
    Core_kernel.Core_hashtbl_intf.create_options_with_hashable
  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 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_exn : ('a, 'b) t -> key:'a key -> data:'b -> unit
  val change : ('a, 'b) t -> 'a key -> ('b option -> 'b option) -> unit
  val add_multi : ('a, 'b list) t -> key:'a key -> data:'b -> unit
  val remove_multi : ('a, 'b list) t -> 'a key -> 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 : ('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 find : ('a, 'b) t -> 'a key -> 'b option
  val find_exn : ('a, 'b) t -> 'a key -> 'b
  val find_and_remove : ('a, 'b) t -> 'a key -> 'b option
  val iter_vals : ('a, 'b) t -> f:('b -> unit) -> unit
  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
  val merge_into :
    f:(key:'a key -> 'b -> 'b option -> 'b option) ->
    src:('a, 'b) t -> dst:('a, 'b) t -> unit
  val keys : ('a, 'b) t -> 'a key list
  val data : ('a, 'b) t -> 'b list
  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
  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 Core_kernel.Validate.check -> ('a, 'b) t Core_kernel.Validate.check
  val incr : ?by:int -> ('a, int) t -> 'a key -> unit
  module Poly :
    sig
      type ('a, 'b) t = ('a, 'b) t
      val hashable : 'a Hashable.t
      type 'a key = 'a
      val create :
        ('a key, unit -> ('a, 'b) t)
        Core_kernel.Core_hashtbl_intf.create_options_without_hashable
      val of_alist :
        ('a key,
         ('a key * 'b) list ->
         [ `Duplicate_key of 'a key | `Ok of ('a, 'b) t ])
        Core_kernel.Core_hashtbl_intf.create_options_without_hashable
      val of_alist_report_all_dups :
        ('a key,
         ('a key * 'b) list ->
         [ `Duplicate_keys of 'a key list | `Ok of ('a, 'b) t ])
        Core_kernel.Core_hashtbl_intf.create_options_without_hashable
      val of_alist_exn :
        ('a key, ('a key * 'b) list -> ('a, 'b) t)
        Core_kernel.Core_hashtbl_intf.create_options_without_hashable
      val of_alist_multi :
        ('a key, ('a key * 'b) list -> ('a, 'b list) t)
        Core_kernel.Core_hashtbl_intf.create_options_without_hashable
      val create_mapped :
        ('a key,
         get_key:('r -> 'a key) ->
         get_data:('r -> 'b) ->
         'r list -> [ `Duplicate_keys of 'a key list | `Ok of ('a, 'b) t ])
        Core_kernel.Core_hashtbl_intf.create_options_without_hashable
      val create_with_key :
        ('a key,
         get_key:('r -> 'a key) ->
         'r list -> [ `Duplicate_keys of 'a key list | `Ok of ('a, 'r) t ])
        Core_kernel.Core_hashtbl_intf.create_options_without_hashable
      val create_with_key_exn :
        ('a key, get_key:('r -> 'a key) -> 'r list -> ('a, 'r) t)
        Core_kernel.Core_hashtbl_intf.create_options_without_hashable
      val group :
        ('a key,
         get_key:('r -> 'a key) ->
         get_data:('r -> 'b) ->
         combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t)
        Core_kernel.Core_hashtbl_intf.create_options_without_hashable
      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 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_exn : ('a, 'b) t -> key:'a key -> data:'b -> unit
      val change : ('a, 'b) t -> 'a key -> ('b option -> 'b option) -> unit
      val add_multi : ('a, 'b list) t -> key:'a key -> data:'b -> unit
      val remove_multi : ('a, 'b list) t -> 'a key -> 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 : ('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 find : ('a, 'b) t -> 'a key -> 'b option
      val find_exn : ('a, 'b) t -> 'a key -> 'b
      val find_and_remove : ('a, 'b) t -> 'a key -> 'b option
      val iter_vals : ('a, 'b) t -> f:('b -> unit) -> unit
      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
      val merge_into :
        f:(key:'a key -> 'b -> 'b option -> 'b option) ->
        src:('a, 'b) t -> dst:('a, 'b) t -> unit
      val keys : ('a, 'b) t -> 'a key list
      val data : ('a, 'b) t -> 'b list
      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
      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 Core_kernel.Validate.check ->
        ('a, 'b) t Core_kernel.Validate.check
      val incr : ?by:int -> ('a, int) t -> 'a key -> unit
      val t_of_sexp :
        (Sexplib.Sexp.t -> 'a) ->
        (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> ('a, 'b) t
      val sexp_of_t :
        ('a -> Sexplib.Sexp.t) ->
        ('b -> Sexplib.Sexp.t) -> ('a, 'b) t -> Sexplib.Sexp.t
      val bin_t :
        'a Bin_prot.Type_class.t ->
        'b Bin_prot.Type_class.t -> ('a, 'b) t Bin_prot.Type_class.t
      val bin_read_t :
        'a Bin_prot.Read.reader ->
        'b Bin_prot.Read.reader -> ('a, 'b) t Bin_prot.Read.reader
      val __bin_read_t__ :
        'a Bin_prot.Read.reader ->
        'b Bin_prot.Read.reader -> (int -> ('a, 'b) t) Bin_prot.Read.reader
      val bin_reader_t :
        'a Bin_prot.Type_class.reader ->
        'b Bin_prot.Type_class.reader ->
        ('a, 'b) t Bin_prot.Type_class.reader
      val bin_size_t :
        'a Bin_prot.Size.sizer ->
        'b Bin_prot.Size.sizer -> ('a, 'b) t Bin_prot.Size.sizer
      val bin_write_t :
        'a Bin_prot.Write.writer ->
        'b Bin_prot.Write.writer -> ('a, 'b) t Bin_prot.Write.writer
      val bin_writer_t :
        'a Bin_prot.Type_class.writer ->
        'b Bin_prot.Type_class.writer ->
        ('a, 'b) t Bin_prot.Type_class.writer
    end
  module type Key = Core_kernel.Core_hashtbl_intf.Key
  module type Key_binable = Core_kernel.Core_hashtbl_intf.Key_binable
  module type S =
    sig
      type key
      type ('a, 'b) hashtbl = ('a, 'b) t
      type 'b t = (key, 'b) hashtbl
      type ('a, 'b) t_ = 'b t
      type 'a key_ = key
      val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
      val create :
        ('a key_, unit -> ('a, 'b) t_)
        Core_kernel.Core_hashtbl_intf.create_options_without_hashable
      val of_alist :
        ('a key_,
         ('a key_ * 'b) list ->
         [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
        Core_kernel.Core_hashtbl_intf.create_options_without_hashable
      val of_alist_report_all_dups :
        ('a key_,
         ('a key_ * 'b) list ->
         [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
        Core_kernel.Core_hashtbl_intf.create_options_without_hashable
      val of_alist_exn :
        ('a key_, ('a key_ * 'b) list -> ('a, 'b) t_)
        Core_kernel.Core_hashtbl_intf.create_options_without_hashable
      val of_alist_multi :
        ('a key_, ('a key_ * 'b) list -> ('a, 'b list) t_)
        Core_kernel.Core_hashtbl_intf.create_options_without_hashable
      val create_mapped :
        ('a key_,
         get_key:('r -> 'a key_) ->
         get_data:('r -> 'b) ->
         'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
        Core_kernel.Core_hashtbl_intf.create_options_without_hashable
      val create_with_key :
        ('a key_,
         get_key:('r -> 'a key_) ->
         'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
        Core_kernel.Core_hashtbl_intf.create_options_without_hashable
      val create_with_key_exn :
        ('a key_, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
        Core_kernel.Core_hashtbl_intf.create_options_without_hashable
      val group :
        ('a key_,
         get_key:('r -> 'a key_) ->
         get_data:('r -> 'b) ->
         combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
        Core_kernel.Core_hashtbl_intf.create_options_without_hashable
      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 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_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
      val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
      val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
      val remove_multi : ('a, 'b list) t_ -> 'a key_ -> 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 : ('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 find : ('a, 'b) t_ -> 'a key_ -> 'b option
      val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
      val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
      val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
      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_
      val merge_into :
        f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
        src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
      val keys : ('a, 'b) t_ -> 'a key_ list
      val data : ('a, 'b) t_ -> 'b list
      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
      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 Core_kernel.Validate.check ->
        ('a, 'b) t_ Core_kernel.Validate.check
      val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
      val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
      val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
    end
  module type S_binable =
    sig
      type key
      type ('a, 'b) hashtbl = ('a, 'b) t
      type 'b t = (key, 'b) hashtbl
      type ('a, 'b) t_ = 'b t
      type 'a key_ = key
      val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
      val create :
        ('a key_, unit -> ('a, 'b) t_)
        Core_kernel.Core_hashtbl_intf.create_options_without_hashable
      val of_alist :
        ('a key_,
         ('a key_ * 'b) list ->
         [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
        Core_kernel.Core_hashtbl_intf.create_options_without_hashable
      val of_alist_report_all_dups :
        ('a key_,
         ('a key_ * 'b) list ->
         [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
        Core_kernel.Core_hashtbl_intf.create_options_without_hashable
      val of_alist_exn :
        ('a key_, ('a key_ * 'b) list -> ('a, 'b) t_)
        Core_kernel.Core_hashtbl_intf.create_options_without_hashable
      val of_alist_multi :
        ('a key_, ('a key_ * 'b) list -> ('a, 'b list) t_)
        Core_kernel.Core_hashtbl_intf.create_options_without_hashable
      val create_mapped :
        ('a key_,
         get_key:('r -> 'a key_) ->
         get_data:('r -> 'b) ->
         'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
        Core_kernel.Core_hashtbl_intf.create_options_without_hashable
      val create_with_key :
        ('a key_,
         get_key:('r -> 'a key_) ->
         'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
        Core_kernel.Core_hashtbl_intf.create_options_without_hashable
      val create_with_key_exn :
        ('a key_, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
        Core_kernel.Core_hashtbl_intf.create_options_without_hashable
      val group :
        ('a key_,
         get_key:('r -> 'a key_) ->
         get_data:('r -> 'b) ->
         combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
        Core_kernel.Core_hashtbl_intf.create_options_without_hashable
      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 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_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
      val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
      val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
      val remove_multi : ('a, 'b list) t_ -> 'a key_ -> 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 : ('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 find : ('a, 'b) t_ -> 'a key_ -> 'b option
      val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
      val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
      val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
      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_
      val merge_into :
        f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
        src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
      val keys : ('a, 'b) t_ -> 'a key_ list
      val data : ('a, 'b) t_ -> 'b list
      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
      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 Core_kernel.Validate.check ->
        ('a, 'b) t_ Core_kernel.Validate.check
      val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
      val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
      val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
      val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
      val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
      val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
      val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
      val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
      val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
      val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
    end
  module Make :
    functor (Key : Key) ->
      sig
        type key = Key.t
        type ('a, 'b) hashtbl = ('a, 'b) t
        type 'b t = (key, 'b) hashtbl
        type ('a, 'b) t_ = 'b t
        type 'a key_ = key
        val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
        val create :
          ('a key_, unit -> ('a, 'b) t_)
          Core_kernel.Core_hashtbl_intf.create_options_without_hashable
        val of_alist :
          ('a key_,
           ('a key_ * 'b) list ->
           [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
          Core_kernel.Core_hashtbl_intf.create_options_without_hashable
        val of_alist_report_all_dups :
          ('a key_,
           ('a key_ * 'b) list ->
           [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
          Core_kernel.Core_hashtbl_intf.create_options_without_hashable
        val of_alist_exn :
          ('a key_, ('a key_ * 'b) list -> ('a, 'b) t_)
          Core_kernel.Core_hashtbl_intf.create_options_without_hashable
        val of_alist_multi :
          ('a key_, ('a key_ * 'b) list -> ('a, 'b list) t_)
          Core_kernel.Core_hashtbl_intf.create_options_without_hashable
        val create_mapped :
          ('a key_,
           get_key:('r -> 'a key_) ->
           get_data:('r -> 'b) ->
           'r list ->
           [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
          Core_kernel.Core_hashtbl_intf.create_options_without_hashable
        val create_with_key :
          ('a key_,
           get_key:('r -> 'a key_) ->
           'r list ->
           [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
          Core_kernel.Core_hashtbl_intf.create_options_without_hashable
        val create_with_key_exn :
          ('a key_, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
          Core_kernel.Core_hashtbl_intf.create_options_without_hashable
        val group :
          ('a key_,
           get_key:('r -> 'a key_) ->
           get_data:('r -> 'b) ->
           combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
          Core_kernel.Core_hashtbl_intf.create_options_without_hashable
        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 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_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
        val change :
          ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
        val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
        val remove_multi : ('a, 'b list) t_ -> 'a key_ -> 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 : ('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 find : ('a, 'b) t_ -> 'a key_ -> 'b option
        val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
        val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
        val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
        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_
        val merge_into :
          f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
          src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
        val keys : ('a, 'b) t_ -> 'a key_ list
        val data : ('a, 'b) t_ -> 'b list
        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
        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 Core_kernel.Validate.check ->
          ('a, 'b) t_ Core_kernel.Validate.check
        val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
        val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
        val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
      end
  module Make_binable :
    functor (Key : Key_binable) ->
      sig
        type key = Key.t
        type ('a, 'b) hashtbl = ('a, 'b) t
        type 'b t = (key, 'b) hashtbl
        type ('a, 'b) t_ = 'b t
        type 'a key_ = key
        val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
        val create :
          ('a key_, unit -> ('a, 'b) t_)
          Core_kernel.Core_hashtbl_intf.create_options_without_hashable
        val of_alist :
          ('a key_,
           ('a key_ * 'b) list ->
           [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
          Core_kernel.Core_hashtbl_intf.create_options_without_hashable
        val of_alist_report_all_dups :
          ('a key_,
           ('a key_ * 'b) list ->
           [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
          Core_kernel.Core_hashtbl_intf.create_options_without_hashable
        val of_alist_exn :
          ('a key_, ('a key_ * 'b) list -> ('a, 'b) t_)
          Core_kernel.Core_hashtbl_intf.create_options_without_hashable
        val of_alist_multi :
          ('a key_, ('a key_ * 'b) list -> ('a, 'b list) t_)
          Core_kernel.Core_hashtbl_intf.create_options_without_hashable
        val create_mapped :
          ('a key_,
           get_key:('r -> 'a key_) ->
           get_data:('r -> 'b) ->
           'r list ->
           [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
          Core_kernel.Core_hashtbl_intf.create_options_without_hashable
        val create_with_key :
          ('a key_,
           get_key:('r -> 'a key_) ->
           'r list ->
           [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
          Core_kernel.Core_hashtbl_intf.create_options_without_hashable
        val create_with_key_exn :
          ('a key_, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
          Core_kernel.Core_hashtbl_intf.create_options_without_hashable
        val group :
          ('a key_,
           get_key:('r -> 'a key_) ->
           get_data:('r -> 'b) ->
           combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
          Core_kernel.Core_hashtbl_intf.create_options_without_hashable
        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 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_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
        val change :
          ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
        val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
        val remove_multi : ('a, 'b list) t_ -> 'a key_ -> 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 : ('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 find : ('a, 'b) t_ -> 'a key_ -> 'b option
        val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
        val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
        val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
        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_
        val merge_into :
          f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
          src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
        val keys : ('a, 'b) t_ -> 'a key_ list
        val data : ('a, 'b) t_ -> 'b list
        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
        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 Core_kernel.Validate.check ->
          ('a, 'b) t_ Core_kernel.Validate.check
        val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
        val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
        val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
        val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
        val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
        val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
        val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
        val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
        val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
        val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
      end
  val sexp_of_t :
    ('a -> Sexplib.Sexp.t) ->
    ('b -> Sexplib.Sexp.t) -> ('a, 'b) t -> Sexplib.Sexp.t
  module Access_control :
    sig
      type ('key, 'data, 'z) any =
          ('key, 'data, 'z) Hashtbl.Access_control.any
      module Immutable :
        sig
          type ('key, 'data) t = ('key, 'data, Core.Std.immutable) any
          val t_of_sexp :
            (Sexplib.Sexp.t -> 'a) ->
            (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> ('a, 'b) t
          val sexp_of_t :
            ('a -> Sexplib.Sexp.t) ->
            ('b -> Sexplib.Sexp.t) -> ('a, 'b) t -> Sexplib.Sexp.t
          val bin_size_t : ('a, 'b, ('a, 'b) t) Bin_prot.Size.sizer2
          val bin_write_t : ('a, 'b, ('a, 'b) t) Bin_prot.Write.writer2
          val bin_read_t : ('a, 'b, ('a, 'b) t) Bin_prot.Read.reader2
          val __bin_read_t__ :
            ('a, 'b, int -> ('a, 'b) t) Bin_prot.Read.reader2
          val bin_writer_t :
            ('a, 'b, ('a, 'b) t) Bin_prot.Type_class.S2.writer
          val bin_reader_t :
            ('a, 'b, ('a, 'b) t) Bin_prot.Type_class.S2.reader
          val bin_t : ('a, 'b, ('a, 'b) t) Bin_prot.Type_class.S2.t
        end
      module Read_only :
        sig
          type ('key, 'data) t = ('key, 'data, Core.Std.read_only) any
          val t_of_sexp :
            (Sexplib.Sexp.t -> 'a) ->
            (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> ('a, 'b) t
          val sexp_of_t :
            ('a -> Sexplib.Sexp.t) ->
            ('b -> Sexplib.Sexp.t) -> ('a, 'b) t -> Sexplib.Sexp.t
          val bin_size_t : ('a, 'b, ('a, 'b) t) Bin_prot.Size.sizer2
          val bin_write_t : ('a, 'b, ('a, 'b) t) Bin_prot.Write.writer2
          val bin_read_t : ('a, 'b, ('a, 'b) t) Bin_prot.Read.reader2
          val __bin_read_t__ :
            ('a, 'b, int -> ('a, 'b) t) Bin_prot.Read.reader2
          val bin_writer_t :
            ('a, 'b, ('a, 'b) t) Bin_prot.Type_class.S2.writer
          val bin_reader_t :
            ('a, 'b, ('a, 'b) t) Bin_prot.Type_class.S2.reader
          val bin_t : ('a, 'b, ('a, 'b) t) Bin_prot.Type_class.S2.t
        end
      module Read_write :
        sig
          type ('key, 'data) t = ('key, 'data, Core.Std.read_write) any
          val t_of_sexp :
            (Sexplib.Sexp.t -> 'a) ->
            (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> ('a, 'b) t
          val sexp_of_t :
            ('a -> Sexplib.Sexp.t) ->
            ('b -> Sexplib.Sexp.t) -> ('a, 'b) t -> Sexplib.Sexp.t
          val bin_size_t : ('a, 'b, ('a, 'b) t) Bin_prot.Size.sizer2
          val bin_write_t : ('a, 'b, ('a, 'b) t) Bin_prot.Write.writer2
          val bin_read_t : ('a, 'b, ('a, 'b) t) Bin_prot.Read.reader2
          val __bin_read_t__ :
            ('a, 'b, int -> ('a, 'b) t) Bin_prot.Read.reader2
          val bin_writer_t :
            ('a, 'b, ('a, 'b) t) Bin_prot.Type_class.S2.writer
          val bin_reader_t :
            ('a, 'b, ('a, 'b) t) Bin_prot.Type_class.S2.reader
          val bin_t : ('a, 'b, ('a, 'b) t) Bin_prot.Type_class.S2.t
        end
      val of_hashtbl :
        ('key, 'data) Core.Std.Hashtbl.t -> ('key, 'data, 'a) any
      val clear : ('a, 'b) Read_write.t -> unit
      val copy : ('a, 'b, 'c) any -> ('a, 'b, 'd) any
      val fold :
        ('a, 'b, 'd) any ->
        init:'c -> f:(key:'a -> data:'b -> 'c -> 'c) -> 'c
      val iter : ('a, 'b, 'c) any -> f:(key:'a -> data:'b -> unit) -> unit
      val existsi : ('a, 'b, 'c) any -> f:(key:'a -> data:'b -> bool) -> bool
      val exists : ('a, 'b, 'c) any -> f:('b -> bool) -> bool
      val length : ('a, 'b, 'c) any -> int
      val is_empty : ('a, 'b, 'c) any -> bool
      val mem : ('a, 'b, 'c) any -> 'a -> bool
      val remove : ('a, 'b) Read_write.t -> 'a -> unit
      val remove_one : ('a, 'b list) Read_write.t -> 'a -> unit
      val replace : ('a, 'b) Read_write.t -> key:'a -> data:'b -> unit
      val set : ('a, 'b) Read_write.t -> key:'a -> data:'b -> unit
      val add :
        ('a, 'b) Read_write.t -> key:'a -> data:'b -> [ `Duplicate | `Ok ]
      val add_exn : ('a, 'b) Read_write.t -> key:'a -> data:'b -> unit
      val change :
        ('a, 'b) Read_write.t -> 'a -> ('b option -> 'b option) -> unit
      val add_multi : ('a, 'b list) Read_write.t -> key:'a -> data:'b -> unit
      val map : ('a, 'b, 'd) any -> f:('b -> 'c) -> ('a, 'c, 'e) any
      val mapi :
        ('a, 'b, 'd) any -> f:(key:'a -> data:'b -> 'c) -> ('a, 'c, 'e) any
      val filter_map :
        ('a, 'b, 'd) any -> f:('b -> 'c option) -> ('a, 'c, 'e) any
      val filter_mapi :
        ('a, 'b, 'd) any ->
        f:(key:'a -> data:'b -> 'c option) -> ('a, 'c, 'e) any
      val filter : ('a, 'b, 'c) any -> f:('b -> bool) -> ('a, 'b, 'd) any
      val filteri :
        ('a, 'b, 'c) any -> f:(key:'a -> data:'b -> bool) -> ('a, 'b, 'd) any
      val find_or_add : ('a, 'b, 'c) any -> 'a -> default:(unit -> 'b) -> 'b
      val find : ('a, 'b, 'c) any -> 'a -> 'b option
      val find_exn : ('a, 'b, 'c) any -> 'a -> 'b
      val iter_vals : ('a, 'b, 'c) any -> f:('b -> unit) -> unit
      val merge :
        ('k, 'a, 'd) any ->
        ('k, 'b, 'e) any ->
        f:(key:'k ->
           [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
        ('k, 'c, 'f) any
      val merge_into :
        f:(key:'a -> 'b -> 'b option -> 'b option) ->
        src:('a, 'b, 'c) any -> dst:('a, 'b) Read_write.t -> unit
      val keys : ('a, 'b, 'c) any -> 'a list
      val data : ('a, 'b, 'c) any -> 'b list
      val filter_inplace : ('a, 'b) Read_write.t -> f:('b -> bool) -> unit
      val filteri_inplace :
        ('a, 'b) Read_write.t -> f:('a -> 'b -> bool) -> unit
      val equal :
        ('a, 'b, 'c) any -> ('a, 'b, 'd) any -> ('b -> 'b -> bool) -> bool
      val to_alist : ('a, 'b, 'c) any -> ('a * 'b) list
      val incr : ?by:int -> ('a, int) Read_write.t -> 'a -> unit
    end
end