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:('-> unit) -> 'a list -> unit
      val map : f:('-> 'b) -> 'a list -> 'b list
      val rev_map : f:('-> 'b) -> 'a list -> 'b list
      val fold_left : f:('-> '-> 'a) -> init:'-> 'b list -> 'a
      val fold_right : f:('-> '-> 'b) -> 'a list -> init:'-> 'b
      val iter2 : f:('-> '-> unit) -> 'a list -> 'b list -> unit
      val map2 : f:('-> '-> 'c) -> 'a list -> 'b list -> 'c list
      val rev_map2 : f:('-> '-> 'c) -> 'a list -> 'b list -> 'c list
      val fold_left2 :
        f:('-> '-> '-> 'a) -> init:'-> 'b list -> 'c list -> 'a
      val fold_right2 :
        f:('-> '-> '-> 'c) -> 'a list -> 'b list -> init:'-> 'c
      val for_all : f:('-> bool) -> 'a list -> bool
      val exists : f:('-> bool) -> 'a list -> bool
      val for_all2 : f:('-> '-> bool) -> 'a list -> 'b list -> bool
      val exists2 : f:('-> '-> bool) -> 'a list -> 'b list -> bool
      val mem : '-> set:'a list -> bool
      val memq : '-> set:'a list -> bool
      val find : f:('-> bool) -> 'a list -> 'a
      val filter : f:('-> bool) -> 'a list -> 'a list
      val find_all : f:('-> bool) -> 'a list -> 'a list
      val partition : f:('-> bool) -> 'a list -> 'a list * 'a list
      val assoc : '-> ('a * 'b) list -> 'b
      val assq : '-> ('a * 'b) list -> 'b
      val mem_assoc : '-> map:('a * 'b) list -> bool
      val mem_assq : '-> map:('a * 'b) list -> bool
      val remove_assoc : '-> ('a * 'b) list -> ('a * 'b) list
      val remove_assq : '-> ('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:('-> '-> int) -> 'a list -> 'a list
      val stable_sort : cmp:('-> '-> int) -> 'a list -> 'a list
      val fast_sort : cmp:('-> '-> int) -> 'a list -> 'a list
      val merge : cmp:('-> '-> 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:('-> 'b elt_ -> 'a) -> init:'-> '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:('-> 'b elt_ -> 'a) -> init:'-> '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:'-> unit
                   val clear : ('a, 'b) t -> unit
                   val create : int -> ('a, 'b) t
                   val fold :
                     f:(key:'a key -> data:'-> '-> 'c) ->
                     ('a, 'b) t -> init:'-> 'c
                   val iter :
                     f:(key:'a key -> data:'-> 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:'-> unit
                 end->
      sig
        type 'a elt_ = '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 -> 'Hashtbl.key -> bool
        val add : ('a, unit) Hashtbl.t -> 'Hashtbl.key -> unit
        val strict_add : ('a, unit) Hashtbl.t -> 'Hashtbl.key -> unit
        val remove : ('a, 'b) Hashtbl.t -> 'Hashtbl.key -> unit
        val strict_remove : ('a, 'b) Hashtbl.t -> 'Hashtbl.key -> unit
        val fold :
          f:('-> 'Hashtbl.key -> 'a) ->
          init:'-> ('b, 'c) Hashtbl.t -> 'a
        val iter : f:('Hashtbl.key -> unit) -> ('a, 'b) Hashtbl.t -> unit
        val to_list : ('a, 'b) Hashtbl.t -> 'Hashtbl.key list
        val of_list : 'Hashtbl.key list -> ('a, unit) Hashtbl.t
        val sexp_of_t :
          ('Hashtbl.key -> Sexplib.Sexp.t) ->
          ('a, 'b) Hashtbl.t -> Sexplib.Sexp.t
        val t_of_sexp :
          (Sexplib.Sexp.t -> 'Hashtbl.key) ->
          Sexplib.Sexp.t -> ('a, unit) Hashtbl.t
      end
  module Poly :
    sig
      type 'a elt_ = 'a
      type 'a set = '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:('-> 'b elt_ -> 'a) -> init:'-> '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 : ('-> 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 = '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:('-> 'b elt_ -> 'a) -> init:'-> '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