sig
  module List :
    sig
      val length : 'a list -> int
      val hd : 'a list -> 'a
      val tl : 'a list -> 'a list
      val nth : 'a list -> int -> 'a
      val rev : 'a list -> 'a list
      val append : 'a list -> 'a list -> 'a list
      val rev_append : 'a list -> 'a list -> 'a list
      val concat : 'a list list -> 'a list
      val flatten : 'a list list -> 'a list
      val iter : f:('a -> unit) -> 'a list -> unit
      val map : f:('a -> 'b) -> 'a list -> 'b list
      val rev_map : f:('a -> 'b) -> 'a list -> 'b list
      val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b list -> 'a
      val fold_right : f:('a -> 'b -> 'b) -> 'a list -> init:'b -> 'b
      val iter2 : f:('a -> 'b -> unit) -> 'a list -> 'b list -> unit
      val map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
      val rev_map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
      val fold_left2 :
        f:('a -> 'b -> 'c -> 'a) -> init:'a -> 'b list -> 'c list -> 'a
      val fold_right2 :
        f:('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> init:'c -> 'c
      val for_all : f:('a -> bool) -> 'a list -> bool
      val exists : f:('a -> bool) -> 'a list -> bool
      val for_all2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool
      val exists2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool
      val mem : 'a -> set:'a list -> bool
      val memq : 'a -> set:'a list -> bool
      val find : f:('a -> bool) -> 'a list -> 'a
      val filter : f:('a -> bool) -> 'a list -> 'a list
      val find_all : f:('a -> bool) -> 'a list -> 'a list
      val partition : f:('a -> bool) -> 'a list -> 'a list * 'a list
      val assoc : 'a -> ('a * 'b) list -> 'b
      val assq : 'a -> ('a * 'b) list -> 'b
      val mem_assoc : 'a -> map:('a * 'b) list -> bool
      val mem_assq : 'a -> map:('a * 'b) list -> bool
      val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list
      val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list
      val split : ('a * 'b) list -> 'a list * 'b list
      val combine : 'a list -> 'b list -> ('a * 'b) list
      val sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list
      val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list
      val fast_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list
      val merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list
    end
  module type Mono_or_poly =
    sig
      type 'a elt_
      type 'a set
      val create : int -> 'a set
      val add : 'a set -> 'a elt_ -> unit
      val strict_add : 'a set -> 'a elt_ -> unit
      val remove : 'a set -> 'a elt_ -> unit
      val strict_remove : 'a set -> 'a elt_ -> unit
      val clear : 'a set -> unit
      val fold : f:('a -> 'b elt_ -> 'a) -> init:'a -> 'b set -> 'a
      val iter : f:('a elt_ -> unit) -> 'a set -> unit
      val length : 'a set -> int
      val mem : 'a set -> 'a elt_ -> bool
      val of_list : 'a elt_ list -> 'a set
      val to_list : 'a set -> 'a elt_ list
    end
  module type Mono =
    sig
      type elt
      type 'a elt_ = elt
      type 'a set
      val create : int -> 'a set
      val add : 'a set -> 'a elt_ -> unit
      val strict_add : 'a set -> 'a elt_ -> unit
      val remove : 'a set -> 'a elt_ -> unit
      val strict_remove : 'a set -> 'a elt_ -> unit
      val clear : 'a set -> unit
      val fold : f:('a -> 'b elt_ -> 'a) -> init:'a -> 'b set -> 'a
      val iter : f:('a elt_ -> unit) -> 'a set -> unit
      val length : 'a set -> int
      val mem : 'a set -> 'a elt_ -> bool
      val of_list : 'a elt_ list -> 'a set
      val to_list : 'a set -> 'a elt_ list
      type t = unit set
      val sexp_of_t : t -> Sexplib.Sexp.t
      val t_of_sexp : Sexplib.Sexp.t -> t
    end
  module Make_mono_or_poly :
    functor
      (Hashtbl : sig
                   type 'a key
                   type ('a, 'b) t
                   val add : ('a, 'b) t -> key:'a key -> data:'b -> unit
                   val clear : ('a, 'b) t -> unit
                   val create : int -> ('a, 'b) t
                   val fold :
                     f:(key:'a key -> data:'b -> 'c -> 'c) ->
                     ('a, 'b) t -> init:'c -> 'c
                   val iter :
                     f:(key:'a key -> data:'b -> unit) -> ('a, 'b) t -> unit
                   val keys : ('a, 'b) t -> 'a key list
                   val length : ('a, 'b) t -> int
                   val mem : ('a, 'b) t -> 'a key -> bool
                   val of_alist : ('a key * 'b) list -> ('a, 'b) t
                   val remove : ('a, 'b) t -> 'a key -> unit
                   val replace : ('a, 'b) t -> key:'a key -> data:'b -> unit
                 end) ->
      sig
        type 'a elt_ = 'a Hashtbl.key
        type 'a set = ('a, unit) Hashtbl.t
        val clear : ('a, 'b) Hashtbl.t -> unit
        val create : int -> ('a, 'b) Hashtbl.t
        val length : ('a, 'b) Hashtbl.t -> int
        val mem : ('a, 'b) Hashtbl.t -> 'a Hashtbl.key -> bool
        val add : ('a, unit) Hashtbl.t -> 'a Hashtbl.key -> unit
        val strict_add : ('a, unit) Hashtbl.t -> 'a Hashtbl.key -> unit
        val remove : ('a, 'b) Hashtbl.t -> 'a Hashtbl.key -> unit
        val strict_remove : ('a, 'b) Hashtbl.t -> 'a Hashtbl.key -> unit
        val fold :
          f:('a -> 'b Hashtbl.key -> 'a) ->
          init:'a -> ('b, 'c) Hashtbl.t -> 'a
        val iter : f:('a Hashtbl.key -> unit) -> ('a, 'b) Hashtbl.t -> unit
        val to_list : ('a, 'b) Hashtbl.t -> 'a Hashtbl.key list
        val of_list : 'a Hashtbl.key list -> ('a, unit) Hashtbl.t
        val sexp_of_t :
          ('a Hashtbl.key -> Sexplib.Sexp.t) ->
          ('a, 'b) Hashtbl.t -> Sexplib.Sexp.t
        val t_of_sexp :
          (Sexplib.Sexp.t -> 'a Hashtbl.key) ->
          Sexplib.Sexp.t -> ('a, unit) Hashtbl.t
      end
  module Poly :
    sig
      type 'a elt_ = 'a
      type 'a set = 'a Hash_set.Poly.set
      val create : int -> 'a set
      val add : 'a set -> 'a elt_ -> unit
      val strict_add : 'a set -> 'a elt_ -> unit
      val remove : 'a set -> 'a elt_ -> unit
      val strict_remove : 'a set -> 'a elt_ -> unit
      val clear : 'a set -> unit
      val fold : f:('a -> 'b elt_ -> 'a) -> init:'a -> 'b set -> 'a
      val iter : f:('a elt_ -> unit) -> 'a set -> unit
      val length : 'a set -> int
      val mem : 'a set -> 'a elt_ -> bool
      val of_list : 'a elt_ list -> 'a set
      val to_list : 'a set -> 'a elt_ list
      type 'a t = 'a set
      val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
      val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
    end
  module Make :
    functor
      (H : sig
             type t
             val equal : t -> t -> bool
             val hash : t -> int
             val sexp_of_t : t -> Sexplib.Sexp.t
             val t_of_sexp : Sexplib.Sexp.t -> t
             val sexp_of_t : t -> Sexplib.Sexp.t
             val t_of_sexp : Sexplib.Sexp.t -> t
           end) ->
      sig
        type elt = H.t
        type 'a elt_ = elt
        type 'a set = 'a Hash_set.Make(H).set
        val create : int -> 'a set
        val add : 'a set -> 'a elt_ -> unit
        val strict_add : 'a set -> 'a elt_ -> unit
        val remove : 'a set -> 'a elt_ -> unit
        val strict_remove : 'a set -> 'a elt_ -> unit
        val clear : 'a set -> unit
        val fold : f:('a -> 'b elt_ -> 'a) -> init:'a -> 'b set -> 'a
        val iter : f:('a elt_ -> unit) -> 'a set -> unit
        val length : 'a set -> int
        val mem : 'a set -> 'a elt_ -> bool
        val of_list : 'a elt_ list -> 'a set
        val to_list : 'a set -> 'a elt_ list
        type t = unit set
        val sexp_of_t : t -> Sexplib.Sexp.t
        val t_of_sexp : Sexplib.Sexp.t -> t
      end
end