functor
  (V : Hptmap.Id_Datatype) (Set : 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 action =
                                        Neutral
                                      | Absorbing
                                      | Traversing of (elt -> bool)
                                    val merge :
                                      cache:Hptmap_sig.cache_type ->
                                      symmetric:bool ->
                                      idempotent:bool ->
                                      decide_both:(elt -> bool) ->
                                      decide_left:action ->
                                      decide_right:action -> t -> t -> t
                                    type 'a shape
                                    val shape : t -> unit shape
                                    val from_shape : 'a shape -> t
                                    val fold2_join_heterogeneous :
                                      cache:Hptmap_sig.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
                                    val pretty_debug :
                                      t Pretty_utils.formatter
                                  end->
  sig
    module O :
      sig
        type t = Set.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 = Set.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 = 'Set.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 = 'Set.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 action =
          Set.action =
            Neutral
          | Absorbing
          | Traversing of (elt -> bool)
        val merge :
          cache:Hptmap_sig.cache_type ->
          symmetric:bool ->
          idempotent:bool ->
          decide_both:(elt -> bool) ->
          decide_left:action -> decide_right:action -> t -> t -> t
        type 'a shape = 'Set.shape
        val shape : t -> unit shape
        val from_shape : 'a shape -> t
        val fold2_join_heterogeneous :
          cache:Hptmap_sig.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
        val pretty_debug : t Pretty_utils.formatter
      end
    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 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 filter : (O.elt -> bool) -> t -> t
    val project : t -> O.t
    val mem : O.elt -> t -> bool
  end