sig
  module type Key =
    sig
      type t
      val ( >= ) : t -> t -> bool
      val ( <= ) : t -> t -> bool
      val ( = ) : t -> t -> bool
      val ( > ) : t -> t -> bool
      val ( < ) : t -> t -> bool
      val ( <> ) : t -> t -> bool
      val equal : t -> t -> bool
      val compare : t -> t -> int
      val min : t -> t -> t
      val max : t -> t -> t
      val ascending : t -> t -> int
      val descending : t -> t -> int
      val between : t -> low:t -> high:t -> bool
      module Replace_polymorphic_compare :
        sig
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
          val _squelch_unused_module_warning_ : unit
        end
      type comparator
      val comparator : (t, comparator) Core_kernel.Comparator.t
      val validate_lbound :
        min:t Core_kernel.Comparable_intf.bound ->
        t Core_kernel.Validate.check
      val validate_ubound :
        max:t Core_kernel.Comparable_intf.bound ->
        t Core_kernel.Validate.check
      val validate_bound :
        min:t Core_kernel.Comparable_intf.bound ->
        max:t Core_kernel.Comparable_intf.bound ->
        t Core_kernel.Validate.check
      module Map :
        sig
          module Key :
            sig
              type t = t
              val compare : t -> t -> int
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type comparator = comparator
              val comparator : (t, comparator) Core_kernel.Comparator.t_
            end
          module Tree :
            sig
              type 'a t =
                  (Key.t, 'a, Key.comparator) Core_kernel.Core_map.Tree.t
              val empty : 'a t
              val singleton : Key.t -> 'a -> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_tree : 'a t -> 'a t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add : 'a t -> key:Key.t -> data:'a -> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
              val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('a -> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
              val fold :
                'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val fold_right :
                'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
              val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
              val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
              val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist : 'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> string) ->
                'a Core_kernel.Validate.check ->
                'a t Core_kernel.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('a -> 'a -> bool) ->
                (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
                list
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('a -> bool) -> bool
              val exists : 'a t -> f:('a -> bool) -> bool
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
              val next_key : 'a t -> Key.t -> (Key.t * 'a) option
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'a t
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
            end
          type 'a t = (Key.t, 'a, Key.comparator) Core_kernel.Core_map.t
          val empty : 'a t
          val singleton : Key.t -> 'a -> 'a t
          val of_alist :
            (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ]
          val of_alist_exn : (Key.t * 'a) list -> 'a t
          val of_alist_multi : (Key.t * 'a) list -> 'a list t
          val of_alist_fold :
            (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
          val of_alist_reduce :
            (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
          val of_sorted_array :
            (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
          val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
          val of_tree : 'a Tree.t -> 'a t
          val invariants : 'a t -> bool
          val is_empty : 'a t -> bool
          val length : 'a t -> int
          val add : 'a t -> key:Key.t -> data:'a -> 'a t
          val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
          val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
          val find : 'a t -> Key.t -> 'a option
          val find_exn : 'a t -> Key.t -> 'a
          val remove : 'a t -> Key.t -> 'a t
          val mem : 'a t -> Key.t -> bool
          val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
          val iter2 :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) ->
            unit
          val map : 'a t -> f:('a -> 'b) -> 'b t
          val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
          val fold :
            'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
          val fold_right :
            'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
          val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
          val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
          val filter_mapi :
            'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
          val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
          val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
          val keys : 'a t -> Key.t list
          val data : 'a t -> 'a list
          val to_alist : 'a t -> (Key.t * 'a) list
          val validate :
            name:(Key.t -> string) ->
            'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check
          val merge :
            'a t ->
            'b t ->
            f:(key:Key.t ->
               [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) ->
            'c t
          val symmetric_diff :
            'a t ->
            'a t ->
            data_equal:('a -> 'a -> bool) ->
            (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
            list
          val min_elt : 'a t -> (Key.t * 'a) option
          val min_elt_exn : 'a t -> Key.t * 'a
          val max_elt : 'a t -> (Key.t * 'a) option
          val max_elt_exn : 'a t -> Key.t * 'a
          val for_all : 'a t -> f:('a -> bool) -> bool
          val exists : 'a t -> f:('a -> bool) -> bool
          val fold_range_inclusive :
            'a t ->
            min:Key.t ->
            max:Key.t ->
            init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
          val range_to_alist :
            'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
          val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
          val next_key : 'a t -> Key.t -> (Key.t * 'a) option
          val rank : 'a t -> Key.t -> int option
          val to_tree : 'a t -> 'a Tree.t
          val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
          val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
          val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
        end
      module Set :
        sig
          module Elt :
            sig
              type t = t
              val compare : t -> t -> int
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type comparator = comparator
              val comparator : (t, comparator) Core_kernel.Comparator.t_
            end
          module Tree :
            sig
              type t = (Elt.t, Elt.comparator) Core_kernel.Core_set.Tree.t
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val subset : t -> t -> bool
              val fold_until :
                t ->
                init:'b ->
                f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
              val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * bool * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map :
                ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t
              val filter_map :
                ('a, 'b) Core_kernel.Core_set.Tree.t ->
                f:('a -> Elt.t option) -> t
              val of_tree : t -> t
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
              val compare : t -> t -> int
            end
          type t = (Elt.t, Elt.comparator) Core_kernel.Core_set.t
          val length : t -> int
          val is_empty : t -> bool
          val iter : t -> f:(Elt.t -> unit) -> unit
          val fold :
            t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
          val exists : t -> f:(Elt.t -> bool) -> bool
          val for_all : t -> f:(Elt.t -> bool) -> bool
          val count : t -> f:(Elt.t -> bool) -> int
          val find : t -> f:(Elt.t -> bool) -> Elt.t option
          val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
          val to_list : t -> Elt.t list
          val to_array : t -> Elt.t array
          val invariants : t -> bool
          val mem : t -> Elt.t -> bool
          val add : t -> Elt.t -> t
          val remove : t -> Elt.t -> t
          val union : t -> t -> t
          val inter : t -> t -> t
          val diff : t -> t -> t
          val compare_direct : t -> t -> int
          val equal : t -> t -> bool
          val subset : t -> t -> bool
          val fold_until :
            t ->
            init:'b ->
            f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
          val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
          val iter2 :
            t ->
            t ->
            f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] ->
               unit) ->
            unit
          val filter : t -> f:(Elt.t -> bool) -> t
          val partition_tf : t -> f:(Elt.t -> bool) -> t * t
          val elements : t -> Elt.t list
          val min_elt : t -> Elt.t option
          val min_elt_exn : t -> Elt.t
          val max_elt : t -> Elt.t option
          val max_elt_exn : t -> Elt.t
          val choose : t -> Elt.t option
          val choose_exn : t -> Elt.t
          val split : t -> Elt.t -> t * bool * t
          val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
          val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
          val find_index : t -> int -> Elt.t option
          val remove_index : t -> int -> t
          val to_tree : t -> Tree.t
          val empty : t
          val singleton : Elt.t -> t
          val union_list : t list -> t
          val of_list : Elt.t list -> t
          val of_array : Elt.t array -> t
          val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t
          val of_sorted_array_unchecked : Elt.t array -> t
          val stable_dedup_list : Elt.t list -> Elt.t list
          val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t
          val filter_map :
            ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t
          val of_tree : Tree.t -> t
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val compare : t -> t -> int
        end
      module Packed_array :
        sig
          type t
          val length : t -> int
          val unsafe_get : t -> int -> t
          val unsafe_slice : t -> pos:int -> len:int -> t
          val bin_elt : t Core.Std.Bin_prot.Type_class.t
          val bin_read_elt : t Core.Std.Bin_prot.Read.reader
          val __bin_read_elt__ : (int -> t) Core.Std.Bin_prot.Read.reader
          val bin_reader_elt : t Core.Std.Bin_prot.Type_class.reader
          val bin_size_elt : t Core.Std.Bin_prot.Size.sizer
          val bin_write_elt : t Core.Std.Bin_prot.Write.writer
          val bin_writer_elt : t Core.Std.Bin_prot.Type_class.writer
          val elt_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_elt : t -> Sexplib.Sexp.t
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
          val get : t -> int -> t
          val slice : t -> pos:int -> len:int -> t
          val iter : t -> f:(t -> unit) -> unit
          val fold : t -> init:'a -> f:('a -> t -> 'a) -> 'a
          val of_array : t array -> t
          val to_array : t -> t array
          val of_list : t list -> t
          val to_list : t -> t list
          val empty : t
        end
      val bin_t : t Core.Std.Bin_prot.Type_class.t
      val bin_read_t : t Core.Std.Bin_prot.Read.reader
      val __bin_read_t__ : (int -> t) Core.Std.Bin_prot.Read.reader
      val bin_reader_t : t Core.Std.Bin_prot.Type_class.reader
      val bin_size_t : t Core.Std.Bin_prot.Size.sizer
      val bin_write_t : t Core.Std.Bin_prot.Write.writer
      val bin_writer_t : t Core.Std.Bin_prot.Type_class.writer
      val t_of_sexp : Sexplib.Sexp.t -> t
      val sexp_of_t : t -> Sexplib.Sexp.t
    end
  module type Value =
    sig
      type t
      module Packed_array :
        sig
          type t
          val length : t -> int
          val unsafe_get : t -> int -> t
          val unsafe_slice : t -> pos:int -> len:int -> t
          val bin_elt : t Core.Std.Bin_prot.Type_class.t
          val bin_read_elt : t Core.Std.Bin_prot.Read.reader
          val __bin_read_elt__ : (int -> t) Core.Std.Bin_prot.Read.reader
          val bin_reader_elt : t Core.Std.Bin_prot.Type_class.reader
          val bin_size_elt : t Core.Std.Bin_prot.Size.sizer
          val bin_write_elt : t Core.Std.Bin_prot.Write.writer
          val bin_writer_elt : t Core.Std.Bin_prot.Type_class.writer
          val elt_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_elt : t -> Sexplib.Sexp.t
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val bin_size_t : t Bin_prot.Size.sizer
          val bin_write_t : t Bin_prot.Write.writer
          val bin_read_t : t Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
          val bin_writer_t : t Bin_prot.Type_class.writer
          val bin_reader_t : t Bin_prot.Type_class.reader
          val bin_t : t Bin_prot.Type_class.t
          val get : t -> int -> t
          val slice : t -> pos:int -> len:int -> t
          val iter : t -> f:(t -> unit) -> unit
          val fold : t -> init:'a -> f:('a -> t -> 'a) -> 'a
          val of_array : t array -> t
          val to_array : t -> t array
          val of_list : t list -> t
          val to_list : t -> t list
          val empty : t
        end
      val bin_t : t Core.Std.Bin_prot.Type_class.t
      val bin_read_t : t Core.Std.Bin_prot.Read.reader
      val __bin_read_t__ : (int -> t) Core.Std.Bin_prot.Read.reader
      val bin_reader_t : t Core.Std.Bin_prot.Type_class.reader
      val bin_size_t : t Core.Std.Bin_prot.Size.sizer
      val bin_write_t : t Core.Std.Bin_prot.Write.writer
      val bin_writer_t : t Core.Std.Bin_prot.Type_class.writer
      val t_of_sexp : Sexplib.Sexp.t -> t
      val sexp_of_t : t -> Sexplib.Sexp.t
    end
  module type S =
    sig
      type t
      type key
      type value
      val empty : t
      val of_alist : (key * value) list -> t
      val to_alist : t -> (key * value) list
      val of_aarray : (key * value) array -> t
      val of_sorted_aarray : (key * value) array -> t
      val of_hashtbl : (key, value) Core.Std.Hashtbl.t -> t
      val find : t -> key -> value option
      val mem : t -> key -> bool
      val iter : t -> f:(key:key -> data:value -> unit) -> unit
      val bin_t : t Core.Std.Bin_prot.Type_class.t
      val bin_read_t : t Core.Std.Bin_prot.Read.reader
      val __bin_read_t__ : (int -> t) Core.Std.Bin_prot.Read.reader
      val bin_reader_t : t Core.Std.Bin_prot.Type_class.reader
      val bin_size_t : t Core.Std.Bin_prot.Size.sizer
      val bin_write_t : t Core.Std.Bin_prot.Write.writer
      val bin_writer_t : t Core.Std.Bin_prot.Type_class.writer
      val t_of_sexp : Sexplib.Sexp.t -> t
      val sexp_of_t : t -> Sexplib.Sexp.t
      val bin_key : key Core.Std.Bin_prot.Type_class.t
      val bin_read_key : key Core.Std.Bin_prot.Read.reader
      val __bin_read_key__ : (int -> key) Core.Std.Bin_prot.Read.reader
      val bin_reader_key : key Core.Std.Bin_prot.Type_class.reader
      val bin_size_key : key Core.Std.Bin_prot.Size.sizer
      val bin_write_key : key Core.Std.Bin_prot.Write.writer
      val bin_writer_key : key Core.Std.Bin_prot.Type_class.writer
      val key_of_sexp : Sexplib.Sexp.t -> key
      val sexp_of_key : key -> Sexplib.Sexp.t
      val bin_value : value Core.Std.Bin_prot.Type_class.t
      val bin_read_value : value Core.Std.Bin_prot.Read.reader
      val __bin_read_value__ : (int -> value) Core.Std.Bin_prot.Read.reader
      val bin_reader_value : value Core.Std.Bin_prot.Type_class.reader
      val bin_size_value : value Core.Std.Bin_prot.Size.sizer
      val bin_write_value : value Core.Std.Bin_prot.Write.writer
      val bin_writer_value : value Core.Std.Bin_prot.Type_class.writer
      val value_of_sexp : Sexplib.Sexp.t -> value
      val sexp_of_value : value -> Sexplib.Sexp.t
    end
  module Make :
    functor (K : Key) ->
      functor (V : Value) ->
        sig
          type t = Packed_map.Make(K)(V).t
          val empty : t
          val of_alist : (K.t * V.t) list -> t
          val to_alist : t -> (K.t * V.t) list
          val of_aarray : (K.t * V.t) array -> t
          val of_sorted_aarray : (K.t * V.t) array -> t
          val of_hashtbl : (K.t, V.t) Core.Std.Hashtbl.t -> t
          val find : t -> K.t -> V.t option
          val mem : t -> K.t -> bool
          val iter : t -> f:(key:K.t -> data:V.t -> unit) -> unit
          val bin_t : t Core.Std.Bin_prot.Type_class.t
          val bin_read_t : t Core.Std.Bin_prot.Read.reader
          val __bin_read_t__ : (int -> t) Core.Std.Bin_prot.Read.reader
          val bin_reader_t : t Core.Std.Bin_prot.Type_class.reader
          val bin_size_t : t Core.Std.Bin_prot.Size.sizer
          val bin_write_t : t Core.Std.Bin_prot.Write.writer
          val bin_writer_t : t Core.Std.Bin_prot.Type_class.writer
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val bin_key : K.t Core.Std.Bin_prot.Type_class.t
          val bin_read_key : K.t Core.Std.Bin_prot.Read.reader
          val __bin_read_key__ : (int -> K.t) Core.Std.Bin_prot.Read.reader
          val bin_reader_key : K.t Core.Std.Bin_prot.Type_class.reader
          val bin_size_key : K.t Core.Std.Bin_prot.Size.sizer
          val bin_write_key : K.t Core.Std.Bin_prot.Write.writer
          val bin_writer_key : K.t Core.Std.Bin_prot.Type_class.writer
          val key_of_sexp : Sexplib.Sexp.t -> K.t
          val sexp_of_key : K.t -> Sexplib.Sexp.t
          val bin_value : V.t Core.Std.Bin_prot.Type_class.t
          val bin_read_value : V.t Core.Std.Bin_prot.Read.reader
          val __bin_read_value__ : (int -> V.t) Core.Std.Bin_prot.Read.reader
          val bin_reader_value : V.t Core.Std.Bin_prot.Type_class.reader
          val bin_size_value : V.t Core.Std.Bin_prot.Size.sizer
          val bin_write_value : V.t Core.Std.Bin_prot.Write.writer
          val bin_writer_value : V.t Core.Std.Bin_prot.Type_class.writer
          val value_of_sexp : Sexplib.Sexp.t -> V.t
          val sexp_of_value : V.t -> Sexplib.Sexp.t
        end
end