functor
  (H : Datatype.Hashtbl) (E : sig
                                type t
                                val ty : t Type.t
                                val name : string
                                val descr : t Descr.t
                                val packed_descr : Structural_descr.pack
                                val reprs : t list
                                val equal : t -> t -> bool
                                val compare : t -> t -> int
                                val hash : t -> int
                                val pretty_code :
                                  Format.formatter -> t -> unit
                                val internal_pretty_code :
                                  Type.precedence ->
                                  Format.formatter -> t -> unit
                                val pretty : Format.formatter -> t -> unit
                                val varname : t -> string
                                val mem_project :
                                  (Project_skeleton.t -> bool) -> t -> bool
                                val copy : t -> t
                                module Set :
                                  sig
                                    type elt = t
                                    type t
                                    val empty : t
                                    val is_empty : t -> bool
                                    val mem : elt -> t -> bool
                                    val add : elt -> t -> t
                                    val singleton : elt -> t
                                    val remove : elt -> t -> t
                                    val union : t -> t -> t
                                    val inter : t -> t -> t
                                    val diff : t -> t -> t
                                    val subset : t -> t -> bool
                                    val iter : (elt -> unit) -> t -> unit
                                    val fold :
                                      (elt -> '-> 'a) -> t -> '-> 'a
                                    val for_all : (elt -> bool) -> t -> bool
                                    val exists : (elt -> bool) -> t -> bool
                                    val filter : (elt -> bool) -> t -> t
                                    val partition :
                                      (elt -> bool) -> t -> t * t
                                    val cardinal : t -> int
                                    val elements : t -> elt list
                                    val choose : t -> elt
                                    val split : elt -> t -> t * bool * t
                                    val find : elt -> t -> elt
                                    val of_list : elt list -> t
                                    val min_elt : t -> elt
                                    val max_elt : t -> elt
                                    val nearest_elt_le : elt -> t -> elt
                                    val nearest_elt_ge : elt -> t -> elt
                                    val ty : t Type.t
                                    val name : string
                                    val descr : t Descr.t
                                    val packed_descr : Structural_descr.pack
                                    val reprs : t list
                                    val equal : t -> t -> bool
                                    val compare : t -> t -> int
                                    val hash : t -> int
                                    val pretty_code :
                                      Format.formatter -> t -> unit
                                    val internal_pretty_code :
                                      Type.precedence ->
                                      Format.formatter -> t -> unit
                                    val pretty :
                                      Format.formatter -> t -> unit
                                    val varname : t -> string
                                    val mem_project :
                                      (Project_skeleton.t -> bool) ->
                                      t -> bool
                                    val copy : t -> t
                                  end
                                module Map :
                                  sig
                                    type key = t
                                    type +'a t
                                    val empty : 'a t
                                    val is_empty : 'a t -> bool
                                    val mem : key -> 'a t -> bool
                                    val add : key -> '-> 'a t -> 'a t
                                    val singleton : key -> '-> 'a t
                                    val remove : key -> 'a t -> 'a t
                                    val merge :
                                      (key ->
                                       'a option -> 'b option -> 'c option) ->
                                      'a t -> 'b t -> 'c t
                                    val compare :
                                      ('-> '-> int) ->
                                      'a t -> 'a t -> int
                                    val equal :
                                      ('-> '-> bool) ->
                                      'a t -> 'a t -> bool
                                    val iter :
                                      (key -> '-> unit) -> 'a t -> unit
                                    val fold :
                                      (key -> '-> '-> 'b) ->
                                      'a t -> '-> 'b
                                    val for_all :
                                      (key -> '-> bool) -> 'a t -> bool
                                    val exists :
                                      (key -> '-> bool) -> 'a t -> bool
                                    val filter :
                                      (key -> '-> bool) -> 'a t -> 'a t
                                    val partition :
                                      (key -> '-> bool) ->
                                      'a t -> 'a t * 'a t
                                    val cardinal : 'a t -> int
                                    val bindings : 'a t -> (key * 'a) list
                                    val min_binding : 'a t -> key * 'a
                                    val max_binding : 'a t -> key * 'a
                                    val choose : 'a t -> key * 'a
                                    val split :
                                      key -> 'a t -> 'a t * 'a option * 'a t
                                    val find : key -> 'a t -> 'a
                                    val map : ('-> 'b) -> 'a t -> 'b t
                                    val mapi :
                                      (key -> '-> 'b) -> 'a t -> 'b t
                                    module Key :
                                      sig
                                        type t = key
                                        val ty : t Type.t
                                        val name : string
                                        val descr : t Descr.t
                                        val packed_descr :
                                          Structural_descr.pack
                                        val reprs : t list
                                        val equal : t -> t -> bool
                                        val compare : t -> t -> int
                                        val hash : t -> int
                                        val pretty_code :
                                          Format.formatter -> t -> unit
                                        val internal_pretty_code :
                                          Type.precedence ->
                                          Format.formatter -> t -> unit
                                        val pretty :
                                          Format.formatter -> t -> unit
                                        val varname : t -> string
                                        val mem_project :
                                          (Project_skeleton.t -> bool) ->
                                          t -> bool
                                        val copy : t -> t
                                      end
                                    module Make :
                                      functor (Data : Datatype.S->
                                        sig
                                          type t = Data.t t
                                          val ty : t Type.t
                                          val name : string
                                          val descr : t Descr.t
                                          val packed_descr :
                                            Structural_descr.pack
                                          val reprs : t list
                                          val equal : t -> t -> bool
                                          val compare : t -> t -> int
                                          val hash : t -> int
                                          val pretty_code :
                                            Format.formatter -> t -> unit
                                          val internal_pretty_code :
                                            Type.precedence ->
                                            Format.formatter -> t -> unit
                                          val pretty :
                                            Format.formatter -> t -> unit
                                          val varname : t -> string
                                          val mem_project :
                                            (Project_skeleton.t -> bool) ->
                                            t -> bool
                                          val copy : t -> t
                                        end
                                  end
                                module Hashtbl :
                                  sig
                                    type key = t
                                    type 'a t
                                    val create : int -> 'a t
                                    val clear : 'a t -> unit
                                    val reset : 'a t -> unit
                                    val copy : 'a t -> 'a t
                                    val add : 'a t -> key -> '-> unit
                                    val remove : 'a t -> key -> unit
                                    val find : 'a t -> key -> 'a
                                    val find_all : 'a t -> key -> 'a list
                                    val replace : 'a t -> key -> '-> unit
                                    val mem : 'a t -> key -> bool
                                    val iter :
                                      (key -> '-> unit) -> 'a t -> unit
                                    val fold :
                                      (key -> '-> '-> 'b) ->
                                      'a t -> '-> 'b
                                    val length : 'a t -> int
                                    val stats : 'a t -> Hashtbl.statistics
                                    val iter_sorted :
                                      ?cmp:(key -> key -> int) ->
                                      (key -> '-> unit) -> 'a t -> unit
                                    val fold_sorted :
                                      ?cmp:(key -> key -> int) ->
                                      (key -> '-> '-> 'b) ->
                                      'a t -> '-> 'b
                                    val iter_sorted_by_entry :
                                      cmp:(key * '-> key * '-> int) ->
                                      (key -> '-> unit) -> 'a t -> unit
                                    val fold_sorted_by_entry :
                                      cmp:(key * '-> key * '-> int) ->
                                      (key -> '-> '-> 'b) ->
                                      'a t -> '-> 'b
                                    val iter_sorted_by_value :
                                      cmp:('-> '-> int) ->
                                      (key -> '-> unit) -> 'a t -> unit
                                    val fold_sorted_by_value :
                                      cmp:('-> '-> int) ->
                                      (key -> '-> '-> 'b) ->
                                      'a t -> '-> 'b
                                    val structural_descr :
                                      Structural_descr.t ->
                                      Structural_descr.t
                                    val make_type : 'Type.t -> 'a t Type.t
                                    val memo :
                                      'a t -> key -> (key -> 'a) -> 'a
                                    module Key :
                                      sig
                                        type t = key
                                        val ty : t Type.t
                                        val name : string
                                        val descr : t Descr.t
                                        val packed_descr :
                                          Structural_descr.pack
                                        val reprs : t list
                                        val equal : t -> t -> bool
                                        val compare : t -> t -> int
                                        val hash : t -> int
                                        val pretty_code :
                                          Format.formatter -> t -> unit
                                        val internal_pretty_code :
                                          Type.precedence ->
                                          Format.formatter -> t -> unit
                                        val pretty :
                                          Format.formatter -> t -> unit
                                        val varname : t -> string
                                        val mem_project :
                                          (Project_skeleton.t -> bool) ->
                                          t -> bool
                                        val copy : t -> t
                                      end
                                    module Make :
                                      functor (Data : Datatype.S->
                                        sig
                                          type t = Data.t t
                                          val ty : t Type.t
                                          val name : string
                                          val descr : t Descr.t
                                          val packed_descr :
                                            Structural_descr.pack
                                          val reprs : t list
                                          val equal : t -> t -> bool
                                          val compare : t -> t -> int
                                          val hash : t -> int
                                          val pretty_code :
                                            Format.formatter -> t -> unit
                                          val internal_pretty_code :
                                            Type.precedence ->
                                            Format.formatter -> t -> unit
                                          val pretty :
                                            Format.formatter -> t -> unit
                                          val varname : t -> string
                                          val mem_project :
                                            (Project_skeleton.t -> bool) ->
                                            t -> bool
                                          val copy : t -> t
                                        end
                                  end
                                val local_clear :
                                  H.key -> 'Hashtbl.t -> unit
                                val usable_get :
                                  t -> Emitter.Usable_emitter.t
                                val get : t -> Emitter.emitter
                              end) (D : Datatype.S) (Info : sig
                                                              val name :
                                                                string
                                                              val dependencies :
                                                                State.t list
                                                              val size : int
                                                              val kinds :
                                                                Emitter.kind
                                                                list
                                                            end->
  sig
    type internal_tbl = D.t E.Hashtbl.t
    val self : State.t
    val add : H.key -> Emitter.Make_table.internal_tbl -> unit
    val find : H.key -> Emitter.Make_table.internal_tbl
    val mem : H.key -> bool
    val iter : (H.key -> Emitter.Make_table.internal_tbl -> unit) -> unit
    val fold :
      (H.key -> Emitter.Make_table.internal_tbl -> '-> 'a) -> '-> 'a
    val iter_sorted :
      cmp:(H.key -> H.key -> int) ->
      (H.key -> Emitter.Make_table.internal_tbl -> unit) -> unit
    val fold_sorted :
      cmp:(H.key -> H.key -> int) ->
      (H.key -> Emitter.Make_table.internal_tbl -> '-> 'a) -> '-> 'a
    val remove : H.key -> unit
    val add_hook_on_remove : (E.t -> H.key -> D.t -> unit) -> unit
    val apply_hooks_on_remove : E.t -> H.key -> D.t -> unit
  end