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