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