functor
  (V : Hptmap.Id_Datatype) (O : 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 hash : t -> int
                                  val pretty_code :
                                    Format.formatter -> t -> unit
                                  val internal_pretty_code :
                                    Type.precedence ->
                                    Format.formatter -> t -> unit
                                  val pretty : Format.formatter -> t -> unit
                                  val varname : t -> string
                                  val mem_project :
                                    (Project_skeleton.t -> bool) -> t -> bool
                                  val copy : t -> t
                                  module Set :
                                    sig
                                      type elt = t
                                      type t
                                      val empty : t
                                      val is_empty : t -> bool
                                      val mem : elt -> t -> bool
                                      val add : elt -> t -> t
                                      val singleton : elt -> t
                                      val remove : elt -> t -> t
                                      val union : t -> t -> t
                                      val inter : t -> t -> t
                                      val diff : t -> t -> t
                                      val subset : t -> t -> bool
                                      val iter : (elt -> unit) -> t -> unit
                                      val fold :
                                        (elt -> '-> 'a) -> t -> '-> 'a
                                      val for_all :
                                        (elt -> bool) -> t -> bool
                                      val exists : (elt -> bool) -> t -> bool
                                      val filter : (elt -> bool) -> t -> t
                                      val partition :
                                        (elt -> bool) -> t -> t * t
                                      val cardinal : t -> int
                                      val elements : t -> elt list
                                      val choose : t -> elt
                                      val split : elt -> t -> t * bool * t
                                      val find : elt -> t -> elt
                                      val of_list : elt list -> t
                                      val min_elt : t -> elt
                                      val max_elt : t -> elt
                                      val nearest_elt_le : elt -> t -> elt
                                      val nearest_elt_ge : elt -> t -> elt
                                      val ty : t Type.t
                                      val name : string
                                      val descr : t Descr.t
                                      val packed_descr :
                                        Structural_descr.pack
                                      val reprs : t list
                                      val equal : t -> t -> bool
                                      val compare : t -> t -> int
                                      val hash : t -> int
                                      val pretty_code :
                                        Format.formatter -> t -> unit
                                      val internal_pretty_code :
                                        Type.precedence ->
                                        Format.formatter -> t -> unit
                                      val pretty :
                                        Format.formatter -> t -> unit
                                      val varname : t -> string
                                      val mem_project :
                                        (Project_skeleton.t -> bool) ->
                                        t -> bool
                                      val copy : t -> t
                                    end
                                  module Map :
                                    sig
                                      type key = t
                                      type +'a t
                                      val empty : 'a t
                                      val is_empty : 'a t -> bool
                                      val mem : key -> 'a t -> bool
                                      val add : key -> '-> 'a t -> 'a t
                                      val singleton : key -> '-> 'a t
                                      val remove : key -> 'a t -> 'a t
                                      val merge :
                                        (key ->
                                         'a option -> 'b option -> 'c option) ->
                                        'a t -> 'b t -> 'c t
                                      val compare :
                                        ('-> '-> int) ->
                                        'a t -> 'a t -> int
                                      val equal :
                                        ('-> '-> bool) ->
                                        'a t -> 'a t -> bool
                                      val iter :
                                        (key -> '-> unit) -> 'a t -> unit
                                      val fold :
                                        (key -> '-> '-> 'b) ->
                                        'a t -> '-> 'b
                                      val for_all :
                                        (key -> '-> bool) -> 'a t -> bool
                                      val exists :
                                        (key -> '-> bool) -> 'a t -> bool
                                      val filter :
                                        (key -> '-> bool) -> 'a t -> 'a t
                                      val partition :
                                        (key -> '-> bool) ->
                                        'a t -> 'a t * 'a t
                                      val cardinal : 'a t -> int
                                      val bindings : 'a t -> (key * 'a) list
                                      val min_binding : 'a t -> key * 'a
                                      val max_binding : 'a t -> key * 'a
                                      val choose : 'a t -> key * 'a
                                      val split :
                                        key ->
                                        'a t -> 'a t * 'a option * 'a t
                                      val find : key -> 'a t -> 'a
                                      val map : ('-> 'b) -> 'a t -> 'b t
                                      val mapi :
                                        (key -> '-> 'b) -> 'a t -> 'b t
                                      module Key :
                                        sig
                                          type t = key
                                          val ty : t Type.t
                                          val name : string
                                          val descr : t Descr.t
                                          val packed_descr :
                                            Structural_descr.pack
                                          val reprs : t list
                                          val equal : t -> t -> bool
                                          val compare : t -> t -> int
                                          val hash : t -> int
                                          val pretty_code :
                                            Format.formatter -> t -> unit
                                          val internal_pretty_code :
                                            Type.precedence ->
                                            Format.formatter -> t -> unit
                                          val pretty :
                                            Format.formatter -> t -> unit
                                          val varname : t -> string
                                          val mem_project :
                                            (Project_skeleton.t -> bool) ->
                                            t -> bool
                                          val copy : t -> t
                                        end
                                      module Make :
                                        functor (Data : Datatype.S->
                                          sig
                                            type t = Data.t t
                                            val ty : t Type.t
                                            val name : string
                                            val descr : t Descr.t
                                            val packed_descr :
                                              Structural_descr.pack
                                            val reprs : t list
                                            val equal : t -> t -> bool
                                            val compare : t -> t -> int
                                            val hash : t -> int
                                            val pretty_code :
                                              Format.formatter -> t -> unit
                                            val internal_pretty_code :
                                              Type.precedence ->
                                              Format.formatter -> t -> unit
                                            val pretty :
                                              Format.formatter -> t -> unit
                                            val varname : t -> string
                                            val mem_project :
                                              (Project_skeleton.t -> bool) ->
                                              t -> bool
                                            val copy : t -> t
                                          end
                                    end
                                  module Hashtbl :
                                    sig
                                      type key = t
                                      type 'a t
                                      val create : int -> 'a t
                                      val clear : 'a t -> unit
                                      val reset : 'a t -> unit
                                      val copy : 'a t -> 'a t
                                      val add : 'a t -> key -> '-> unit
                                      val remove : 'a t -> key -> unit
                                      val find : 'a t -> key -> 'a
                                      val find_all : 'a t -> key -> 'a list
                                      val replace : 'a t -> key -> '-> unit
                                      val mem : 'a t -> key -> bool
                                      val iter :
                                        (key -> '-> unit) -> 'a t -> unit
                                      val fold :
                                        (key -> '-> '-> 'b) ->
                                        'a t -> '-> 'b
                                      val length : 'a t -> int
                                      val stats : 'a t -> Hashtbl.statistics
                                      val iter_sorted :
                                        ?cmp:(key -> key -> int) ->
                                        (key -> '-> unit) -> 'a t -> unit
                                      val fold_sorted :
                                        ?cmp:(key -> key -> int) ->
                                        (key -> '-> '-> 'b) ->
                                        'a t -> '-> 'b
                                      val iter_sorted_by_entry :
                                        cmp:(key * '-> key * '-> int) ->
                                        (key -> '-> unit) -> 'a t -> unit
                                      val fold_sorted_by_entry :
                                        cmp:(key * '-> key * '-> int) ->
                                        (key -> '-> '-> 'b) ->
                                        'a t -> '-> 'b
                                      val iter_sorted_by_value :
                                        cmp:('-> '-> int) ->
                                        (key -> '-> unit) -> 'a t -> unit
                                      val fold_sorted_by_value :
                                        cmp:('-> '-> int) ->
                                        (key -> '-> '-> 'b) ->
                                        'a t -> '-> 'b
                                      val structural_descr :
                                        Structural_descr.t ->
                                        Structural_descr.t
                                      val make_type :
                                        'Type.t -> 'a t Type.t
                                      val memo :
                                        'a t -> key -> (key -> 'a) -> 'a
                                      module Key :
                                        sig
                                          type t = key
                                          val ty : t Type.t
                                          val name : string
                                          val descr : t Descr.t
                                          val packed_descr :
                                            Structural_descr.pack
                                          val reprs : t list
                                          val equal : t -> t -> bool
                                          val compare : t -> t -> int
                                          val hash : t -> int
                                          val pretty_code :
                                            Format.formatter -> t -> unit
                                          val internal_pretty_code :
                                            Type.precedence ->
                                            Format.formatter -> t -> unit
                                          val pretty :
                                            Format.formatter -> t -> unit
                                          val varname : t -> string
                                          val mem_project :
                                            (Project_skeleton.t -> bool) ->
                                            t -> bool
                                          val copy : t -> t
                                        end
                                      module Make :
                                        functor (Data : Datatype.S->
                                          sig
                                            type t = Data.t t
                                            val ty : t Type.t
                                            val name : string
                                            val descr : t Descr.t
                                            val packed_descr :
                                              Structural_descr.pack
                                            val reprs : t list
                                            val equal : t -> t -> bool
                                            val compare : t -> t -> int
                                            val hash : t -> int
                                            val pretty_code :
                                              Format.formatter -> t -> unit
                                            val internal_pretty_code :
                                              Type.precedence ->
                                              Format.formatter -> t -> unit
                                            val pretty :
                                              Format.formatter -> t -> unit
                                            val varname : t -> string
                                            val mem_project :
                                              (Project_skeleton.t -> bool) ->
                                              t -> bool
                                            val copy : t -> t
                                          end
                                    end
                                  type elt = V.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 compare : t -> t -> int
                                  val equal : t -> t -> bool
                                  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 contains_single_elt : t -> elt option
                                  val intersects : t -> t -> bool
                                  type 'a shape
                                  val shape : t -> unit shape
                                  val from_shape : 'a shape -> t
                                  val fold2_join_heterogeneous :
                                    cache:Hptmap.cache_type ->
                                    empty_left:('a shape -> 'b) ->
                                    empty_right:(t -> 'b) ->
                                    both:(elt -> '-> 'b) ->
                                    join:('-> '-> 'b) ->
                                    empty:'-> t -> 'a shape -> 'b
                                  val clear_caches : unit -> unit
                                end->
  sig
    module O :
      sig
        type t = O.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 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 = O.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 = 'O.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 : Datatype.S->
                sig
                  type t = Data.t t
                  val ty : t Type.t
                  val name : string
                  val descr : t Descr.t
                  val packed_descr : Structural_descr.pack
                  val reprs : t list
                  val equal : t -> t -> bool
                  val compare : t -> t -> int
                  val hash : t -> int
                  val pretty_code : Format.formatter -> t -> unit
                  val internal_pretty_code :
                    Type.precedence -> Format.formatter -> t -> unit
                  val pretty : Format.formatter -> t -> unit
                  val varname : t -> string
                  val mem_project : (Project_skeleton.t -> bool) -> t -> bool
                  val copy : t -> t
                end
          end
        module Hashtbl :
          sig
            type key = t
            type 'a t = 'O.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 : Datatype.S->
                sig
                  type t = Data.t t
                  val ty : t Type.t
                  val name : string
                  val descr : t Descr.t
                  val packed_descr : Structural_descr.pack
                  val reprs : t list
                  val equal : t -> t -> bool
                  val compare : t -> t -> int
                  val hash : t -> int
                  val pretty_code : Format.formatter -> t -> unit
                  val internal_pretty_code :
                    Type.precedence -> Format.formatter -> t -> unit
                  val pretty : Format.formatter -> t -> unit
                  val varname : t -> string
                  val mem_project : (Project_skeleton.t -> bool) -> t -> bool
                  val copy : t -> t
                end
          end
        type elt = V.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 compare : t -> t -> int
        val equal : t -> t -> bool
        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 contains_single_elt : t -> elt option
        val intersects : t -> t -> bool
        type 'a shape = 'O.shape
        val shape : t -> unit shape
        val from_shape : 'a shape -> t
        val fold2_join_heterogeneous :
          cache:Hptmap.cache_type ->
          empty_left:('a shape -> 'b) ->
          empty_right:(t -> 'b) ->
          both:(elt -> '-> 'b) ->
          join:('-> '-> 'b) -> empty:'-> t -> 'a shape -> 'b
        val clear_caches : unit -> unit
      end
    exception Error_Top
    type t = private Set of O.t | Top
    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 join : t -> t -> t
    val is_included : t -> t -> bool
    val join_and_is_included : t -> t -> t * bool
    val bottom : t
    val top : t
    type widen_hint = O.t
    val widen : widen_hint -> t -> t -> t
    val cardinal_zero_or_one : t -> bool
    val narrow : t -> t -> t
    val link : t -> t -> t
    val meet : t -> t -> t
    val intersects : t -> t -> bool
    val inject_singleton : O.elt -> t
    val inject : O.t -> t
    val empty : t
    val apply2 : (O.elt -> O.elt -> O.elt) -> t -> t -> t
    val apply1 : (O.elt -> O.elt) -> t -> t
    val fold : (O.elt -> '-> 'a) -> t -> '-> 'a
    val iter : (O.elt -> unit) -> t -> unit
    val exists : (O.elt -> bool) -> t -> bool
    val for_all : (O.elt -> bool) -> t -> bool
    val project : t -> O.t
    val mem : O.elt -> t -> bool
  end