functor (Info : sig val name : string end->
  sig
    module D :
      sig
        type 'a t =
          'Datatype.t = private {
          equal : '-> '-> bool;
          compare : '-> '-> int;
          hash : '-> int;
          copy : '-> 'a;
          internal_pretty_code :
            Type.precedence -> Format.formatter -> '-> unit;
          pretty_code : Format.formatter -> '-> unit;
          pretty : Format.formatter -> '-> unit;
          varname : '-> string;
          mem_project : (Project_skeleton.t -> bool) -> '-> bool;
        }
        module type Ty = sig type t val ty : t Type.t end
        module type S_no_copy =
          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
          end
        module type S =
          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
          end
        val info : 'Type.t -> 'a t
        val equal : 'Type.t -> '-> '-> bool
        val compare : 'Type.t -> '-> '-> int
        val hash : 'Type.t -> '-> int
        val copy : 'Type.t -> '-> 'a
        val internal_pretty_code :
          'Type.t -> Type.precedence -> Format.formatter -> '-> unit
        val pretty_code : 'Type.t -> Format.formatter -> '-> unit
        val pretty : 'Type.t -> Format.formatter -> '-> unit
        val varname : 'Type.t -> '-> string
        val mem_project :
          'Type.t -> (Project_skeleton.t -> bool) -> '-> bool
        val undefined : '-> 'b
        val identity : '-> 'a
        val from_compare : '-> '-> bool
        val from_pretty_code : Format.formatter -> '-> unit
        val never_any_project : (Project_skeleton.t -> bool) -> '-> bool
        val pp_fail : Type.precedence -> Format.formatter -> '-> unit
        module type Undefined =
          sig
            val structural_descr : Structural_descr.t
            val equal : '-> '-> bool
            val compare : '-> '-> int
            val hash : '-> int
            val rehash : '-> 'a
            val copy : '-> 'a
            val internal_pretty_code :
              Type.precedence -> Format.formatter -> '-> unit
            val pretty : Format.formatter -> '-> unit
            val varname : '-> string
            val mem_project : (Project_skeleton.t -> bool) -> '-> bool
          end
        module Undefined :
          sig
            val structural_descr : Structural_descr.t
            val equal : '-> '-> bool
            val compare : '-> '-> int
            val hash : '-> int
            val rehash : '-> 'a
            val copy : '-> 'a
            val internal_pretty_code :
              Type.precedence -> Format.formatter -> '-> unit
            val pretty : Format.formatter -> '-> unit
            val varname : '-> string
            val mem_project : (Project_skeleton.t -> bool) -> '-> bool
          end
        module Serializable_undefined :
          sig
            val structural_descr : Structural_descr.t
            val equal : '-> '-> bool
            val compare : '-> '-> int
            val hash : '-> int
            val rehash : '-> 'a
            val copy : '-> 'a
            val internal_pretty_code :
              Type.precedence -> Format.formatter -> '-> unit
            val pretty : Format.formatter -> '-> unit
            val varname : '-> string
            val mem_project : (Project_skeleton.t -> bool) -> '-> bool
          end
        module type Make_input =
          sig
            type t
            val name : string
            val rehash : t -> t
            val structural_descr : Structural_descr.t
            val reprs : t list
            val equal : t -> t -> bool
            val compare : t -> t -> int
            val hash : t -> int
            val copy : t -> t
            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
          end
        module Make :
          functor (X : Make_input->
            sig
              type t = X.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
        module type Functor_info = sig val module_name : string end
        module type Set =
          sig
            type elt
            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 type Map =
          sig
            type key
            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 : 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 type Hashtbl_with_descr =
          sig
            type key
            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
          end
        module type Hashtbl =
          sig
            type key
            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 : 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 type S_with_collections =
          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 : 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 : 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
          end
        module Make_with_collections :
          functor (X : Make_input->
            sig
              type t = X.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 = Datatype.Make_with_collections(X).Set.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 = 'Datatype.Make_with_collections(X).Map.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 : 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 = 'Datatype.Make_with_collections(X).Hashtbl.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 : 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
            end
        module With_collections :
          functor (X : S->
            functor (Info : Functor_info->
              sig
                type t = X.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 = Datatype.With_collections(X)(Info).Set.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 = 'Datatype.With_collections(X)(Info).Map.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 : 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 =
                        'Datatype.With_collections(X)(Info).Hashtbl.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 : 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
              end
        module Unit :
          sig
            type t = unit
            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 = Datatype.Unit.Set.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 = 'Datatype.Unit.Map.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 : 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 = 'Datatype.Unit.Hashtbl.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 : 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
          end
        val unit : unit Type.t
        module Bool :
          sig
            type t = bool
            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 = Datatype.Bool.Set.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 = 'Datatype.Bool.Map.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 : 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 = 'Datatype.Bool.Hashtbl.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 : 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
          end
        val bool : bool Type.t
        module Int :
          sig
            type t = int
            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 = Datatype.Int.Set.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 = 'Datatype.Int.Map.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 : 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 = 'Datatype.Int.Hashtbl.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 : 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
          end
        val int : int Type.t
        module Int32 :
          sig
            type t = int32
            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 = Datatype.Int32.Set.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 = 'Datatype.Int32.Map.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 : 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 = 'Datatype.Int32.Hashtbl.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 : 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
          end
        val int32 : int32 Type.t
        module Int64 :
          sig
            type t = int64
            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 = Datatype.Int64.Set.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 = 'Datatype.Int64.Map.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 : 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 = 'Datatype.Int64.Hashtbl.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 : 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
          end
        val int64 : int64 Type.t
        module Nativeint :
          sig
            type t = nativeint
            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 = Datatype.Nativeint.Set.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 = 'Datatype.Nativeint.Map.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 : 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 = 'Datatype.Nativeint.Hashtbl.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 : 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
          end
        val nativeint : nativeint Type.t
        module Float :
          sig
            type t = float
            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 = Datatype.Float.Set.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 = 'Datatype.Float.Map.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 : 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 = 'Datatype.Float.Hashtbl.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 : 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
          end
        val float : float Type.t
        module Char :
          sig
            type t = char
            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 = Datatype.Char.Set.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 = 'Datatype.Char.Map.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 : 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 = 'Datatype.Char.Hashtbl.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 : 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
          end
        val char : char Type.t
        module String :
          sig
            type t = string
            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 = Datatype.String.Set.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 = 'Datatype.String.Map.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 : 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 = 'Datatype.String.Hashtbl.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 : 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
          end
        val string : string Type.t
        module Formatter :
          sig
            type t = Format.formatter
            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
        val formatter : Format.formatter Type.t
        module Big_int :
          sig
            type t = Integer.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 = Datatype.Big_int.Set.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 = 'Datatype.Big_int.Map.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 : 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 = 'Datatype.Big_int.Hashtbl.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 : 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
          end
        val big_int : Big_int.t Type.t
        module type Polymorphic =
          sig
            type 'a poly
            val instantiate : 'Type.t -> 'a poly Type.t * bool
            val is_instance_of : 'Type.t -> bool
            val get_instance : 'a poly Type.t -> 'Type.t
            module Make :
              functor (T : S->
                sig
                  type t = T.t poly
                  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 Polymorphic :
          functor
            (P : sig
                   val name : 'Type.t -> string
                   val module_name : string
                   val structural_descr :
                     Structural_descr.t -> Structural_descr.t
                   type 'a t
                   val reprs : '-> 'a t list
                   val mk_equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                   val mk_compare : ('-> '-> int) -> 'a t -> 'a t -> int
                   val mk_hash : ('-> int) -> 'a t -> int
                   val map : ('-> 'a) -> 'a t -> 'a t
                   val mk_internal_pretty_code :
                     (Type.precedence -> Format.formatter -> '-> unit) ->
                     Type.precedence -> Format.formatter -> 'a t -> unit
                   val mk_pretty :
                     (Format.formatter -> '-> unit) ->
                     Format.formatter -> 'a t -> unit
                   val mk_varname : ('-> string) -> 'a t -> string
                   val mk_mem_project :
                     ((Project_skeleton.t -> bool) -> '-> bool) ->
                     (Project_skeleton.t -> bool) -> 'a t -> bool
                 end->
            sig
              type 'a poly = 'P.t
              val instantiate : 'Type.t -> 'a poly Type.t * bool
              val is_instance_of : 'Type.t -> bool
              val get_instance : 'a poly Type.t -> 'Type.t
              module Make :
                functor (T : S->
                  sig
                    type t = T.t poly
                    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 type Polymorphic2 =
          sig
            type ('a, 'b) poly
            val instantiate :
              'Type.t -> 'Type.t -> ('a, 'b) poly Type.t * bool
            val is_instance_of : 'Type.t -> bool
            val get_instance : ('a, 'b) poly Type.t -> 'Type.t * 'Type.t
            module Make :
              functor (T1 : S->
                functor (T2 : S->
                  sig
                    type t = (T1.t, T2.t) poly
                    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 Polymorphic2 :
          functor
            (P : sig
                   val name : 'Type.t -> 'Type.t -> string
                   val module_name : string
                   val structural_descr :
                     Structural_descr.t ->
                     Structural_descr.t -> Structural_descr.t
                   type ('a, 'b) t
                   val reprs : '-> '-> ('a, 'b) t list
                   val mk_equal :
                     ('-> '-> bool) ->
                     ('-> '-> bool) -> ('a, 'b) t -> ('a, 'b) t -> bool
                   val mk_compare :
                     ('-> '-> int) ->
                     ('-> '-> int) -> ('a, 'b) t -> ('a, 'b) t -> int
                   val mk_hash :
                     ('-> int) -> ('-> int) -> ('a, 'b) t -> int
                   val map :
                     ('-> 'a) -> ('-> 'b) -> ('a, 'b) t -> ('a, 'b) t
                   val mk_internal_pretty_code :
                     (Type.precedence -> Format.formatter -> '-> unit) ->
                     (Type.precedence -> Format.formatter -> '-> unit) ->
                     Type.precedence ->
                     Format.formatter -> ('a, 'b) t -> unit
                   val mk_pretty :
                     (Format.formatter -> '-> unit) ->
                     (Format.formatter -> '-> unit) ->
                     Format.formatter -> ('a, 'b) t -> unit
                   val mk_varname :
                     ('-> string) -> ('-> string) -> ('a, 'b) t -> string
                   val mk_mem_project :
                     ((Project_skeleton.t -> bool) -> '-> bool) ->
                     ((Project_skeleton.t -> bool) -> '-> bool) ->
                     (Project_skeleton.t -> bool) -> ('a, 'b) t -> bool
                 end->
            sig
              type ('a, 'b) poly = ('a, 'b) P.t
              val instantiate :
                'Type.t -> 'Type.t -> ('a, 'b) poly Type.t * bool
              val is_instance_of : 'Type.t -> bool
              val get_instance :
                ('a, 'b) poly Type.t -> 'Type.t * 'Type.t
              module Make :
                functor (T1 : S->
                  functor (T2 : S->
                    sig
                      type t = (T1.t, T2.t) poly
                      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 type Polymorphic3 =
          sig
            type ('a, 'b, 'c) poly
            val instantiate :
              'Type.t ->
              'Type.t -> 'Type.t -> ('a, 'b, 'c) poly Type.t * bool
            val is_instance_of : 'Type.t -> bool
            val get_instance :
              ('a, 'b, 'c) poly Type.t -> 'Type.t * 'Type.t * 'Type.t
            module Make :
              functor (T1 : S->
                functor (T2 : S->
                  functor (T3 : S->
                    sig
                      type t = (T1.t, T2.t, T3.t) poly
                      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 Polymorphic3 :
          functor
            (P : sig
                   val name : 'Type.t -> 'Type.t -> 'Type.t -> string
                   val module_name : string
                   val structural_descr :
                     Structural_descr.t ->
                     Structural_descr.t ->
                     Structural_descr.t -> Structural_descr.t
                   type ('a, 'b, 'c) t
                   val reprs : '-> '-> '-> ('a, 'b, 'c) t list
                   val mk_equal :
                     ('-> '-> bool) ->
                     ('-> '-> bool) ->
                     ('-> '-> bool) ->
                     ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> bool
                   val mk_compare :
                     ('-> '-> int) ->
                     ('-> '-> int) ->
                     ('-> '-> int) ->
                     ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> int
                   val mk_hash :
                     ('-> int) ->
                     ('-> int) -> ('-> int) -> ('a, 'b, 'c) t -> int
                   val map :
                     ('-> 'a) ->
                     ('-> 'b) ->
                     ('-> 'c) -> ('a, 'b, 'c) t -> ('a, 'b, 'c) t
                   val mk_internal_pretty_code :
                     (Type.precedence -> Format.formatter -> '-> unit) ->
                     (Type.precedence -> Format.formatter -> '-> unit) ->
                     (Type.precedence -> Format.formatter -> '-> unit) ->
                     Type.precedence ->
                     Format.formatter -> ('a, 'b, 'c) t -> unit
                   val mk_pretty :
                     (Format.formatter -> '-> unit) ->
                     (Format.formatter -> '-> unit) ->
                     (Format.formatter -> '-> unit) ->
                     Format.formatter -> ('a, 'b, 'c) t -> unit
                   val mk_varname :
                     ('-> string) ->
                     ('-> string) ->
                     ('-> string) -> ('a, 'b, 'c) t -> string
                   val mk_mem_project :
                     ((Project_skeleton.t -> bool) -> '-> bool) ->
                     ((Project_skeleton.t -> bool) -> '-> bool) ->
                     ((Project_skeleton.t -> bool) -> '-> bool) ->
                     (Project_skeleton.t -> bool) -> ('a, 'b, 'c) t -> bool
                 end->
            sig
              type ('a, 'b, 'c) poly = ('a, 'b, 'c) P.t
              val instantiate :
                'Type.t ->
                'Type.t -> 'Type.t -> ('a, 'b, 'c) poly Type.t * bool
              val is_instance_of : 'Type.t -> bool
              val get_instance :
                ('a, 'b, 'c) poly Type.t -> 'Type.t * 'Type.t * 'Type.t
              module Make :
                functor (T1 : S->
                  functor (T2 : S->
                    functor (T3 : S->
                      sig
                        type t = (T1.t, T2.t, T3.t) poly
                        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 type Polymorphic4 =
          sig
            type ('a, 'b, 'c, 'd) poly
            val instantiate :
              'Type.t ->
              'Type.t ->
              'Type.t -> 'Type.t -> ('a, 'b, 'c, 'd) poly Type.t * bool
            val is_instance_of : 'Type.t -> bool
            val get_instance :
              ('a, 'b, 'c, 'd) poly Type.t ->
              'Type.t * 'Type.t * 'Type.t * 'Type.t
            module Make :
              functor (T1 : S->
                functor (T2 : S->
                  functor (T3 : S->
                    functor (T4 : S->
                      sig
                        type t = (T1.t, T2.t, T3.t, T4.t) poly
                        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 Polymorphic4 :
          functor
            (P : sig
                   val name :
                     'Type.t ->
                     'Type.t -> 'Type.t -> 'Type.t -> string
                   val module_name : string
                   val structural_descr :
                     Structural_descr.t ->
                     Structural_descr.t ->
                     Structural_descr.t ->
                     Structural_descr.t -> Structural_descr.t
                   type ('a, 'b, 'c, 'd) t
                   val reprs :
                     '-> '-> '-> '-> ('a, 'b, 'c, 'd) t list
                   val mk_equal :
                     ('-> '-> bool) ->
                     ('-> '-> bool) ->
                     ('-> '-> bool) ->
                     ('-> '-> bool) ->
                     ('a, 'b, 'c, 'd) t -> ('a, 'b, 'c, 'd) t -> bool
                   val mk_compare :
                     ('-> '-> int) ->
                     ('-> '-> int) ->
                     ('-> '-> int) ->
                     ('-> '-> int) ->
                     ('a, 'b, 'c, 'd) t -> ('a, 'b, 'c, 'd) t -> int
                   val mk_hash :
                     ('-> int) ->
                     ('-> int) ->
                     ('-> int) -> ('-> int) -> ('a, 'b, 'c, 'd) t -> int
                   val map :
                     ('-> 'a) ->
                     ('-> 'b) ->
                     ('-> 'c) ->
                     ('-> 'd) -> ('a, 'b, 'c, 'd) t -> ('a, 'b, 'c, 'd) t
                   val mk_internal_pretty_code :
                     (Type.precedence -> Format.formatter -> '-> unit) ->
                     (Type.precedence -> Format.formatter -> '-> unit) ->
                     (Type.precedence -> Format.formatter -> '-> unit) ->
                     (Type.precedence -> Format.formatter -> '-> unit) ->
                     Type.precedence ->
                     Format.formatter -> ('a, 'b, 'c, 'd) t -> unit
                   val mk_pretty :
                     (Format.formatter -> '-> unit) ->
                     (Format.formatter -> '-> unit) ->
                     (Format.formatter -> '-> unit) ->
                     (Format.formatter -> '-> unit) ->
                     Format.formatter -> ('a, 'b, 'c, 'd) t -> unit
                   val mk_varname :
                     ('-> string) ->
                     ('-> string) ->
                     ('-> string) ->
                     ('-> string) -> ('a, 'b, 'c, 'd) t -> string
                   val mk_mem_project :
                     ((Project_skeleton.t -> bool) -> '-> bool) ->
                     ((Project_skeleton.t -> bool) -> '-> bool) ->
                     ((Project_skeleton.t -> bool) -> '-> bool) ->
                     ((Project_skeleton.t -> bool) -> '-> bool) ->
                     (Project_skeleton.t -> bool) ->
                     ('a, 'b, 'c, 'd) t -> bool
                 end->
            sig
              type ('a, 'b, 'c, 'd) poly = ('a, 'b, 'c, 'd) P.t
              val instantiate :
                'Type.t ->
                'Type.t ->
                'Type.t -> 'Type.t -> ('a, 'b, 'c, 'd) poly Type.t * bool
              val is_instance_of : 'Type.t -> bool
              val get_instance :
                ('a, 'b, 'c, 'd) poly Type.t ->
                'Type.t * 'Type.t * 'Type.t * 'Type.t
              module Make :
                functor (T1 : S->
                  functor (T2 : S->
                    functor (T3 : S->
                      functor (T4 : S->
                        sig
                          type t = (T1.t, T2.t, T3.t, T4.t) poly
                          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 Poly_pair :
          sig
            type ('a, 'b) poly = 'a * 'b
            val instantiate :
              'Type.t -> 'Type.t -> ('a, 'b) poly Type.t * bool
            val is_instance_of : 'Type.t -> bool
            val get_instance : ('a, 'b) poly Type.t -> 'Type.t * 'Type.t
            module Make :
              functor (T1 : S->
                functor (T2 : S->
                  sig
                    type t = (T1.t, T2.t) poly
                    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 Pair :
          functor (T1 : S->
            functor (T2 : S->
              sig
                type t = T1.t * T2.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
        module Pair_with_collections :
          functor (T1 : S->
            functor (T2 : S->
              functor (Info : Functor_info->
                sig
                  type t = T1.t * T2.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 =
                          Datatype.Pair_with_collections(T1)(T2)(Info).Set.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 =
                          'a
                          Datatype.Pair_with_collections(T1)(T2)(Info).Map.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 : 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 =
                          'a
                          Datatype.Pair_with_collections(T1)(T2)(Info).Hashtbl.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 : 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
                end
        val pair : 'Type.t -> 'Type.t -> ('a * 'b) Type.t
        module Poly_ref :
          sig
            type 'a poly = 'a ref
            val instantiate : 'Type.t -> 'a poly Type.t * bool
            val is_instance_of : 'Type.t -> bool
            val get_instance : 'a poly Type.t -> 'Type.t
            module Make :
              functor (T : S->
                sig
                  type t = T.t poly
                  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 Ref :
          functor (T : S->
            sig
              type t = T.t ref
              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
        val t_ref : 'Type.t -> 'a ref Type.t
        module Poly_option :
          sig
            type 'a poly = 'a option
            val instantiate : 'Type.t -> 'a poly Type.t * bool
            val is_instance_of : 'Type.t -> bool
            val get_instance : 'a poly Type.t -> 'Type.t
            module Make :
              functor (T : S->
                sig
                  type t = T.t poly
                  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 Option :
          functor (T : S->
            sig
              type t = T.t option
              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 Option_with_collections :
          functor (T : S->
            functor (Info : Functor_info->
              sig
                type t = T.t option
                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 = Datatype.Option_with_collections(T)(Info).Set.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 =
                        'Datatype.Option_with_collections(T)(Info).Map.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 : 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 =
                        'a
                        Datatype.Option_with_collections(T)(Info).Hashtbl.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 : 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
              end
        val option : 'Type.t -> 'a option Type.t
        module Poly_list :
          sig
            type 'a poly = 'a list
            val instantiate : 'Type.t -> 'a poly Type.t * bool
            val is_instance_of : 'Type.t -> bool
            val get_instance : 'a poly Type.t -> 'Type.t
            module Make :
              functor (T : S->
                sig
                  type t = T.t poly
                  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 List :
          functor (T : S->
            sig
              type t = T.t list
              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 List_with_collections :
          functor (T : S->
            functor (Info : Functor_info->
              sig
                type t = T.t list
                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 = Datatype.List_with_collections(T)(Info).Set.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 =
                        'Datatype.List_with_collections(T)(Info).Map.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 : 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 =
                        'Datatype.List_with_collections(T)(Info).Hashtbl.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 : 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
              end
        val list : 'Type.t -> 'a list Type.t
        module Poly_array :
          sig
            type 'a poly = 'a array
            val instantiate : 'Type.t -> 'a poly Type.t * bool
            val is_instance_of : 'Type.t -> bool
            val get_instance : 'a poly Type.t -> 'Type.t
            module Make :
              functor (T : S->
                sig
                  type t = T.t poly
                  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 Array :
          functor (T : S->
            sig
              type t = T.t array
              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 Array_with_collections :
          functor (T : S->
            functor (Info : Functor_info->
              sig
                type t = T.t array
                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 = Datatype.Array_with_collections(T)(Info).Set.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 =
                        'Datatype.Array_with_collections(T)(Info).Map.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 : 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 =
                        'Datatype.Array_with_collections(T)(Info).Hashtbl.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 : 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
              end
        val array : 'Type.t -> 'a array Type.t
        module Poly_queue :
          sig
            type 'a poly = 'Queue.t
            val instantiate : 'Type.t -> 'a poly Type.t * bool
            val is_instance_of : 'Type.t -> bool
            val get_instance : 'a poly Type.t -> 'Type.t
            module Make :
              functor (T : S->
                sig
                  type t = T.t poly
                  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 queue : 'Type.t -> 'Queue.t Type.t
        module Queue :
          functor (T : S->
            sig
              type t = T.t Queue.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
        module Triple :
          functor (T1 : S->
            functor (T2 : S->
              functor (T3 : S->
                sig
                  type t = T1.t * T2.t * T3.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
        val triple :
          'Type.t -> 'Type.t -> 'Type.t -> ('a * 'b * 'c) Type.t
        module Triple_with_collections :
          functor (T1 : S->
            functor (T2 : S->
              functor (T3 : S->
                functor (Info : Functor_info->
                  sig
                    type t = T1.t * T2.t * T3.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 =
                            Datatype.Triple_with_collections(T1)(T2)(T3)(Info).Set.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 =
                            'a
                            Datatype.Triple_with_collections(T1)(T2)(T3)(Info).Map.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 : 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 =
                            'a
                            Datatype.Triple_with_collections(T1)(T2)(T3)(Info).Hashtbl.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 : 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
                  end
        module Quadruple :
          functor (T1 : S->
            functor (T2 : S->
              functor (T3 : S->
                functor (T4 : S->
                  sig
                    type t = T1.t * T2.t * T3.t * T4.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
        val quadruple :
          'Type.t ->
          'Type.t -> 'Type.t -> 'Type.t -> ('a * 'b * 'c * 'd) Type.t
        module Quadruple_with_collections :
          functor (T1 : S->
            functor (T2 : S->
              functor (T3 : S->
                functor (T4 : S->
                  functor (Info : Functor_info->
                    sig
                      type t = T1.t * T2.t * T3.t * T4.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 =
                              Datatype.Quadruple_with_collections(T1)(T2)(T3)(T4)(Info).Set.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 =
                              'a
                              Datatype.Quadruple_with_collections(T1)(T2)(T3)(T4)(Info).Map.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 : 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 =
                              'a
                              Datatype.Quadruple_with_collections(T1)(T2)(T3)(T4)(Info).Hashtbl.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 : 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
                    end
        module Function :
          functor
            (T1 : 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
                    val label : (string * (unit -> t) option) option
                  end->
            functor (T2 : S->
              sig
                type t = T1.t -> T2.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
        val func :
          ?label:string * (unit -> 'a) option ->
          'Type.t -> 'Type.t -> ('-> 'b) Type.t
        val optlabel_func :
          string ->
          (unit -> 'a) -> 'Type.t -> 'Type.t -> ('-> 'b) Type.t
        val func2 :
          ?label1:string * (unit -> 'a) option ->
          'Type.t ->
          ?label2:string * (unit -> 'b) option ->
          'Type.t -> 'Type.t -> ('-> '-> 'c) Type.t
        val func3 :
          ?label1:string * (unit -> 'a) option ->
          'Type.t ->
          ?label2:string * (unit -> 'b) option ->
          'Type.t ->
          ?label3:string * (unit -> 'c) option ->
          'Type.t -> 'Type.t -> ('-> '-> '-> 'd) Type.t
        val func4 :
          ?label1:string * (unit -> 'a) option ->
          'Type.t ->
          ?label2:string * (unit -> 'b) option ->
          'Type.t ->
          ?label3:string * (unit -> 'c) option ->
          'Type.t ->
          ?label4:string * (unit -> 'd) option ->
          'Type.t -> 'Type.t -> ('-> '-> '-> '-> 'e) Type.t
        module Set :
          functor (S : FCSet.S->
            functor
              (E : sig
                     type t = S.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->
              functor (Info : Functor_info->
                sig
                  type elt = E.t
                  type t = S.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 :
          functor (M : FCMap.S->
            functor
              (Key : sig
                       type t = M.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->
              functor (Info : Functor_info->
                sig
                  type key = M.key
                  type 'a t = 'M.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 = M.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 : 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 :
          functor (H : Hashtbl_with_descr->
            functor
              (Key : sig
                       type t = H.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->
              functor (Info : Functor_info->
                sig
                  type key = H.key
                  type 'a t = 'H.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 = H.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 : 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 type Sub_caml_weak_hashtbl =
          sig
            type data
            type t
            val create : int -> t
            val add : t -> data -> unit
          end
        module Caml_weak_hashtbl :
          functor (D : S->
            sig
              type data = D.t
              type t = Weak.Make(D).t
              val create : int -> t
              val clear : t -> unit
              val merge : t -> data -> data
              val add : t -> data -> unit
              val remove : t -> data -> unit
              val find : t -> data -> data
              val find_all : t -> data -> data list
              val mem : t -> data -> bool
              val iter : (data -> unit) -> t -> unit
              val fold : (data -> '-> 'a) -> t -> '-> 'a
              val count : t -> int
              val stats : t -> int * int * int * int * int * int
              module Datatype :
                sig
                  type 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 Weak :
          functor (W : Sub_caml_weak_hashtbl->
            functor
              (D : sig
                     type t = W.data
                     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->
              sig
                type t = W.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 self : State.t
    val name : string
    val mark_as_computed : ?project:Project.t -> unit -> unit
    val is_computed : ?project:Project.t -> unit -> bool
    module Datatype : Datatype.S
    val add_hook_on_update : (Datatype.t -> unit) -> unit
    val howto_marshal : (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit
    type data = Cil_datatype.Stmt.Map.Make(Datatype.String.Set).t
    val set : data -> unit
    val get : unit -> data
    val clear : unit -> unit
    val set : data -> unit
  end