functor (U : sig  end) ->
  sig
    type name
    type t = Identifier.Make.name
    val register : string -> Identifier.Make.name
    val print : Identifier.Make.name -> string
    val equal : Identifier.Make.name -> Identifier.Make.name -> bool
    val compare : Identifier.Make.name -> Identifier.Make.name -> int
    val hash : Identifier.Make.name -> int
    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
    val memoize : (Identifier.Make.name -> 'a) -> Identifier.Make.name -> 'a
  end