sig
  module Set :
    sig
      module type S =
        sig
          type elt
          type t
          val is_empty : Collection.Set.S.t -> bool
          val mem : Collection.Set.S.t -> Collection.Set.S.elt -> bool
          val cardinal : Collection.Set.S.t -> int
          val iter :
            (Collection.Set.S.elt -> unit) -> Collection.Set.S.t -> unit
          val fold :
            (Collection.Set.S.elt -> '-> 'a) ->
            Collection.Set.S.t -> '-> 'a
          val elements : Collection.Set.S.t -> Collection.Set.S.elt list
          val equal : Collection.Set.S.t -> Collection.Set.S.t -> bool
        end
      module type IS =
        sig
          type elt
          type t
          val is_empty : t -> bool
          val mem : t -> elt -> bool
          val cardinal : t -> int
          val iter : (elt -> unit) -> t -> unit
          val fold : (elt -> '-> 'a) -> t -> '-> 'a
          val elements : t -> elt list
          val equal : t -> t -> bool
          val create : int -> t
          val clear : t -> unit
          val copy : t -> t
          val add : t -> elt -> unit
          val remove : t -> elt -> unit
        end
      module type PS =
        sig
          type elt
          type t
          val is_empty : t -> bool
          val mem : t -> elt -> bool
          val cardinal : t -> int
          val iter : (elt -> unit) -> t -> unit
          val fold : (elt -> '-> 'a) -> t -> '-> 'a
          val elements : t -> elt list
          val equal : t -> t -> bool
          val empty : t
          val add : t -> elt -> t
          val remove : t -> elt -> t
          val filter : (elt -> bool) -> t -> t
        end
      module Imperative :
        sig
          module MakeHashSet :
            functor (T : Hashtbl.HashedType->
              sig
                type elt = T.t
                type t
                val is_empty : t -> bool
                val mem : t -> elt -> bool
                val cardinal : t -> int
                val iter : (elt -> unit) -> t -> unit
                val fold : (elt -> '-> 'a) -> t -> '-> 'a
                val elements : t -> elt list
                val equal : t -> t -> bool
                val create : int -> t
                val clear : t -> unit
                val copy : t -> t
                val add : t -> elt -> unit
                val remove : t -> elt -> unit
              end
          module MakeMutable :
            functor (Set : PS->
              sig
                type elt = Set.elt
                type t
                val is_empty : t -> bool
                val mem : t -> elt -> bool
                val cardinal : t -> int
                val iter : (elt -> unit) -> t -> unit
                val fold : (elt -> '-> 'a) -> t -> '-> 'a
                val elements : t -> elt list
                val equal : t -> t -> bool
                val create : int -> t
                val clear : t -> unit
                val copy : t -> t
                val add : t -> elt -> unit
                val remove : t -> elt -> unit
              end
        end
      module Persistent :
        sig
          module MakeTreeSet :
            functor (T : Set.OrderedType->
              sig
                type elt = T.t
                type t
                val is_empty : t -> bool
                val mem : t -> elt -> bool
                val cardinal : t -> int
                val iter : (elt -> unit) -> t -> unit
                val fold : (elt -> '-> 'a) -> t -> '-> 'a
                val elements : t -> elt list
                val equal : t -> t -> bool
                val empty : t
                val add : t -> elt -> t
                val remove : t -> elt -> t
                val filter : (elt -> bool) -> t -> t
              end
        end
    end
  module Map :
    sig
      module type M =
        sig
          type key
          type 'a t
          val is_empty : 'Collection.Map.M.t -> bool
          val mem : 'Collection.Map.M.t -> Collection.Map.M.key -> bool
          val find : 'Collection.Map.M.t -> Collection.Map.M.key -> 'a
          val size : 'Collection.Map.M.t -> int
          val iter :
            (Collection.Map.M.key -> '-> unit) ->
            'Collection.Map.M.t -> unit
          val fold :
            (Collection.Map.M.key -> '-> '-> 'b) ->
            'Collection.Map.M.t -> '-> 'b
        end
      module type IM =
        sig
          type key
          type 'a t
          val is_empty : 'a t -> bool
          val mem : 'a t -> key -> bool
          val find : 'a t -> key -> 'a
          val size : 'a t -> int
          val iter : (key -> '-> unit) -> 'a t -> unit
          val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
          val create : int -> 'a t
          val clear : 'a t -> unit
          val copy : 'a t -> 'a t
          val add : 'a t -> key -> '-> unit
          val remove : 'a t -> key -> unit
        end
      module type PM =
        sig
          type key
          type 'a t
          val is_empty : 'a t -> bool
          val mem : 'a t -> key -> bool
          val find : 'a t -> key -> 'a
          val size : 'a t -> int
          val iter : (key -> '-> unit) -> 'a t -> unit
          val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
          val empty : 'a t
          val add : 'a t -> key -> '-> 'a t
          val remove : 'a t -> key -> 'a t
        end
      module Imperative :
        sig
          module MakeHashMap :
            functor (T : Hashtbl.HashedType->
              sig
                type key = T.t
                type 'a t
                val is_empty : 'a t -> bool
                val mem : 'a t -> key -> bool
                val find : 'a t -> key -> 'a
                val size : 'a t -> int
                val iter : (key -> '-> unit) -> 'a t -> unit
                val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                val create : int -> 'a t
                val clear : 'a t -> unit
                val copy : 'a t -> 'a t
                val add : 'a t -> key -> '-> unit
                val remove : 'a t -> key -> unit
              end
          module MakeMutable :
            functor (Map : PM->
              sig
                type key = Map.key
                type 'a t
                val is_empty : 'a t -> bool
                val mem : 'a t -> key -> bool
                val find : 'a t -> key -> 'a
                val size : 'a t -> int
                val iter : (key -> '-> unit) -> 'a t -> unit
                val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                val create : int -> 'a t
                val clear : 'a t -> unit
                val copy : 'a t -> 'a t
                val add : 'a t -> key -> '-> unit
                val remove : 'a t -> key -> unit
              end
        end
      module Persistent :
        sig
          module MakeTreeMap :
            functor (T : Map.OrderedType->
              sig
                type key = T.t
                type 'a t
                val is_empty : 'a t -> bool
                val mem : 'a t -> key -> bool
                val find : 'a t -> key -> 'a
                val size : 'a t -> int
                val iter : (key -> '-> unit) -> 'a t -> unit
                val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                val empty : 'a t
                val add : 'a t -> key -> '-> 'a t
                val remove : 'a t -> key -> 'a t
              end
        end
    end
end