sig
  module MakeNamespace :
    functor
      (I : sig
             type name
             val print : Namespace.MakeNamespace.name -> string
             module Map :
               sig
                 type key = name
                 type 'a t
                 val empty : 'a t
                 val lookup : key -> 'a t -> 'a
                 val find : key -> 'a t -> 'a
                 val add : key -> 'a -> 'a t -> 'a t
                 exception Unchanged
                 val strict_add : key -> 'a -> 'a t -> 'a t
                 type 'a decision = 'a -> 'a -> 'a
                 val fine_add : 'a decision -> key -> 'a -> 'a t -> 'a t
                 val mem : key -> 'a t -> bool
                 val singleton : key -> 'a -> 'a t
                 val is_empty : 'a t -> bool
                 val is_singleton : 'a t -> (key * 'a) option
                 val cardinal : 'a t -> int
                 val choose : 'a t -> key * 'a
                 val lookup_and_remove : key -> 'a t -> 'a * 'a t
                 val find_and_remove : key -> 'a t -> 'a * 'a t
                 val remove : key -> 'a t -> 'a t
                 val union : 'a t -> 'a t -> 'a t
                 val fine_union : 'a decision -> 'a t -> 'a t -> 'a t
                 val iter : (key -> 'a -> unit) -> 'a t -> unit
                 val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
                 val fold_rev : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
                 val iter2 :
                   (key -> 'a -> 'b -> unit) -> 'a t -> 'b t -> unit
                 val map : ('a -> 'b) -> 'a t -> 'b t
                 val endo_map : ('a -> 'a) -> 'a t -> 'a t
                 val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
                 module Domain :
                   sig
                     type element = key
                     type t
                     val empty : t
                     val is_empty : t -> bool
                     val singleton : element -> t
                     val cardinal : t -> int
                     val choose : t -> element
                     val mem : element -> t -> bool
                     val add : element -> t -> t
                     val remove : element -> t -> t
                     val union : t -> t -> t
                     val diff : t -> t -> t
                     val inter : t -> t -> t
                     val disjoint : t -> t -> bool
                     val iter : (element -> unit) -> t -> unit
                     val fold : (element -> 'b -> 'b) -> t -> 'b -> 'b
                     val elements : t -> element list
                     val compare : t -> t -> int
                     val equal : t -> t -> bool
                     val subset : t -> t -> bool
                   end
                 val domain : 'a t -> Domain.t
                 val lift : (key -> 'a) -> Domain.t -> 'a t
                 val corestrict : 'a t -> Domain.t -> 'a t
               end
           end) ->
      sig
        type name = I.name
        type 'a global_env
        val empty : 'a global_env
        val lookup_unqualified : name -> 'a global_env -> 'a
        val extend_unqualified : name -> 'a -> 'a global_env -> 'a global_env
        val lookup_qualified : Module.name -> name -> 'a global_env -> 'a
        val extend_qualified :
          Module.name -> name -> 'a -> 'a global_env -> 'a global_env
        val lookup_maybe_qualified :
          name SurfaceSyntax.maybe_qualified -> 'a global_env -> 'a
        val qualify : Module.name -> name -> 'a global_env -> 'a global_env
        val freeze : Module.name -> 'a global_env -> 'a global_env
        val unqualify : Module.name -> 'a global_env -> 'a global_env
        val zap : 'a global_env -> 'a global_env
        val unqualified_names : 'a global_env -> name list
        val print_global_env :
          ('a -> PPrint.document) -> 'a global_env -> PPrint.document
      end
end