functor (S1 : Hashable_sexpable->
  functor (S2 : Hashable_sexpable->
    sig
      type hashable = S1.hashable * S2.hashable
      module Hashable : sig type t = hashable end
      val hash : hashable -> int
      module Table : Hashable.Table_sig(Hashable).S
      module Hash_set :
        sig
          type elem = hashable
          type t = elem Hash_set.t
          type sexpable = t
          val sexp_of_t : sexpable -> Sexplib.Sexp.t
          val t_of_sexp : Sexplib.Sexp.t -> sexpable
          val create : ?growth_allowed:bool -> ?size:int -> unit -> t
          val of_list : elem list -> t
        end
      module Hash_queue :
        sig
          module Key :
            sig
              type t = hashable
              val compare : t -> t -> int
              val hash : t -> int
              type sexpable = t
              val sexp_of_t : sexpable -> Sexplib.Sexp.t
              val t_of_sexp : Sexplib.Sexp.t -> sexpable
            end
          type 'a t
          type 'a container = 'a t
          val length : 'a container -> int
          val is_empty : 'a container -> bool
          val iter : 'a container -> f:('-> unit) -> unit
          val fold : 'a container -> init:'-> f:('-> '-> 'b) -> 'b
          val exists : 'a container -> f:('-> bool) -> bool
          val for_all : 'a container -> f:('-> bool) -> bool
          val find : 'a container -> f:('-> bool) -> 'a option
          val to_list : 'a container -> 'a list
          val to_array : 'a container -> 'a array
          val container : ('a, 'a container) Container.type_class
          val invariant : 'a t -> unit
          val create : unit -> 'a t
          val clear : 'a t -> unit
          val mem : 'a t -> Key.t -> bool
          val lookup : 'a t -> Key.t -> 'a option
          val lookup_exn : 'a t -> Key.t -> 'a
          val enqueue : 'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
          val enqueue_exn : 'a t -> Key.t -> '-> unit
          val keys : 'a t -> Key.t list
          val dequeue : 'a t -> 'a option
          val dequeue_exn : 'a t -> 'a
          val dequeue_with_key : 'a t -> (Key.t * 'a) option
          val dequeue_with_key_exn : 'a t -> Key.t * 'a
          val dequeue_all : 'a t -> f:('-> unit) -> unit
          val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
          val remove_exn : 'a t -> Key.t -> unit
          val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
          val replace_exn : 'a t -> Key.t -> '-> unit
          val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
          val foldi :
            'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
        end
      module Hash_heap :
        sig
          module Key :
            sig
              type t = hashable
              val compare : t -> t -> int
              val hash : t -> int
              type sexpable = t
              val sexp_of_t : sexpable -> Sexplib.Sexp.t
              val t_of_sexp : Sexplib.Sexp.t -> sexpable
            end
          type 'a t
          val create : ?min_size:int -> ('-> '-> int) -> 'a t
          val copy : 'a t -> 'a t
          val push :
            'a t -> key:Key.t -> data:'-> [ `Key_already_present | `Ok ]
          val push_exn : 'a t -> key:Key.t -> data:'-> unit
          val replace : 'a t -> key:Key.t -> data:'-> unit
          val remove : 'a t -> Key.t -> unit
          val mem : 'a t -> Key.t -> bool
          val top : 'a t -> 'a option
          val top_exn : 'a t -> 'a
          val top_with_key : 'a t -> (Key.t * 'a) option
          val top_with_key_exn : 'a t -> Key.t * 'a
          val pop_with_key : 'a t -> (Key.t * 'a) option
          val pop_with_key_exn : 'a t -> Key.t * 'a
          val pop : 'a t -> 'a option
          val pop_exn : 'a t -> 'a
          val cond_pop_with_key :
            'a t -> (key:Key.t -> data:'-> bool) -> (Key.t * 'a) option
          val cond_pop : 'a t -> ('-> bool) -> 'a option
          val find : 'a t -> Key.t -> 'a option
          val find_pop : 'a t -> Key.t -> 'a option
          val find_exn : 'a t -> Key.t -> 'a
          val find_pop_exn : 'a t -> Key.t -> 'a
          val iter : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
          val iter_vals : 'a t -> f:('-> unit) -> unit
        end
    end