functor (V : Hptmap.Id_Datatype)
  (Set : sig
           type 'a map
           type t = unit map
           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 disjoint : t -> t -> bool
               val diff : t -> t -> t
               val subset : t -> t -> bool
               val iter : (elt -> unit) -> t -> unit
               val map : (elt -> elt) -> t -> t
               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 filter_map : (elt -> elt option) -> t -> t
               val partition : (elt -> bool) -> t -> t * t
               val cardinal : t -> int
               val elements : t -> elt list
               val min_elt : t -> elt
               val min_elt_opt : t -> elt option
               val max_elt : t -> elt
               val max_elt_opt : t -> elt option
               val choose : t -> elt
               val choose_opt : t -> elt option
               val split : elt -> t -> t * bool * t
               val find : elt -> t -> elt
               val find_opt : elt -> t -> elt option
               val find_first : (elt -> bool) -> t -> elt
               val find_first_opt : (elt -> bool) -> t -> elt option
               val find_last : (elt -> bool) -> t -> elt
               val find_last_opt : (elt -> bool) -> t -> elt option
               val of_list : elt list -> t
               val to_seq_from : elt -> t -> elt Seq.t
               val to_seq : t -> elt Seq.t
               val to_rev_seq : t -> elt Seq.t
               val add_seq : elt Seq.t -> t -> t
               val of_seq : elt Seq.t -> t
               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 update : key -> ('a option -> 'a option) -> '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 union :
                 (key -> '-> '-> 'a option) -> 'a t -> 'a t -> 'a 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 filter_map : (key -> '-> 'b option) -> 'a t -> 'b 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 min_binding_opt : 'a t -> (key * 'a) option
               val max_binding : 'a t -> key * 'a
               val max_binding_opt : 'a t -> (key * 'a) option
               val choose : 'a t -> key * 'a
               val choose_opt : 'a t -> (key * 'a) option
               val split : key -> 'a t -> 'a t * 'a option * 'a t
               val find : key -> 'a t -> 'a
               val find_opt : key -> 'a t -> 'a option
               val find_first : (key -> bool) -> 'a t -> key * 'a
               val find_first_opt :
                 (key -> bool) -> 'a t -> (key * 'a) option
               val find_last : (key -> bool) -> 'a t -> key * 'a
               val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
               val map : ('-> 'b) -> 'a t -> 'b t
               val mapi : (key -> '-> 'b) -> 'a t -> 'b t
               val to_seq : 'a t -> (key * 'a) Seq.t
               val to_rev_seq : 'a t -> (key * 'a) Seq.t
               val to_seq_from : key -> 'a t -> (key * 'a) Seq.t
               val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t
               val of_seq : (key * 'a) Seq.t -> 'a 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 filter_map_inplace :
                 (key -> '-> 'a option) -> 'a t -> unit
               val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
               val length : 'a t -> int
               val stats : 'a t -> Hashtbl.statistics
               val to_seq : 'a t -> (key * 'a) Seq.t
               val to_seq_keys : 'a t -> key Seq.t
               val to_seq_values : 'a t -> 'Seq.t
               val add_seq : 'a t -> (key * 'a) Seq.t -> unit
               val replace_seq : 'a t -> (key * 'a) Seq.t -> unit
               val of_seq : (key * 'a) Seq.t -> 'a t
               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 find_opt : 'a t -> key -> 'a option
               val find_def : 'a t -> key -> '-> 'a
               val memo : 'a t -> key -> (key -> 'a) -> 'a
               val structural_descr :
                 Structural_descr.t -> Structural_descr.t
               val make_type : 'Type.t -> 'a t Type.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
           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 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
           val from_map : 'a map -> t
           val fold2_join_heterogeneous :
             cache:Hptmap_sig.cache_type ->
             empty_left:('a map -> 'b) ->
             empty_right:(t -> 'b) ->
             both:(elt -> '-> 'b) ->
             join:('-> '-> 'b) -> empty:'-> t -> 'a map -> 'b
           val replace : elt map -> t -> bool * t
           val clear_caches : unit -> unit
           val pretty_debug : t Pretty_utils.formatter
         end)
  ->
  sig
    module O :
      sig
        type 'a map = 'Set.map
        type t = unit map
        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 disjoint : t -> t -> bool
            val diff : t -> t -> t
            val subset : t -> t -> bool
            val iter : (elt -> unit) -> t -> unit
            val map : (elt -> elt) -> t -> t
            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 filter_map : (elt -> elt option) -> t -> t
            val partition : (elt -> bool) -> t -> t * t
            val cardinal : t -> int
            val elements : t -> elt list
            val min_elt : t -> elt
            val min_elt_opt : t -> elt option
            val max_elt : t -> elt
            val max_elt_opt : t -> elt option
            val choose : t -> elt
            val choose_opt : t -> elt option
            val split : elt -> t -> t * bool * t
            val find : elt -> t -> elt
            val find_opt : elt -> t -> elt option
            val find_first : (elt -> bool) -> t -> elt
            val find_first_opt : (elt -> bool) -> t -> elt option
            val find_last : (elt -> bool) -> t -> elt
            val find_last_opt : (elt -> bool) -> t -> elt option
            val of_list : elt list -> t
            val to_seq_from : elt -> t -> elt Seq.t
            val to_seq : t -> elt Seq.t
            val to_rev_seq : t -> elt Seq.t
            val add_seq : elt Seq.t -> t -> t
            val of_seq : elt Seq.t -> t
            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 update : key -> ('a option -> 'a option) -> '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 union :
              (key -> '-> '-> 'a option) -> 'a t -> 'a t -> 'a 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 filter_map : (key -> '-> 'b option) -> 'a t -> 'b 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 min_binding_opt : 'a t -> (key * 'a) option
            val max_binding : 'a t -> key * 'a
            val max_binding_opt : 'a t -> (key * 'a) option
            val choose : 'a t -> key * 'a
            val choose_opt : 'a t -> (key * 'a) option
            val split : key -> 'a t -> 'a t * 'a option * 'a t
            val find : key -> 'a t -> 'a
            val find_opt : key -> 'a t -> 'a option
            val find_first : (key -> bool) -> 'a t -> key * 'a
            val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
            val find_last : (key -> bool) -> 'a t -> key * 'a
            val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
            val map : ('-> 'b) -> 'a t -> 'b t
            val mapi : (key -> '-> 'b) -> 'a t -> 'b t
            val to_seq : 'a t -> (key * 'a) Seq.t
            val to_rev_seq : 'a t -> (key * 'a) Seq.t
            val to_seq_from : key -> 'a t -> (key * 'a) Seq.t
            val add_seq : (key * 'a) Seq.t -> 'a t -> 'a t
            val of_seq : (key * 'a) Seq.t -> 'a 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 filter_map_inplace : (key -> '-> 'a option) -> 'a t -> unit
            val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
            val length : 'a t -> int
            val stats : 'a t -> Hashtbl.statistics
            val to_seq : 'a t -> (key * 'a) Seq.t
            val to_seq_keys : 'a t -> key Seq.t
            val to_seq_values : 'a t -> 'Seq.t
            val add_seq : 'a t -> (key * 'a) Seq.t -> unit
            val replace_seq : 'a t -> (key * 'a) Seq.t -> unit
            val of_seq : (key * 'a) Seq.t -> 'a t
            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 find_opt : 'a t -> key -> 'a option
            val find_def : 'a t -> key -> '-> 'a
            val memo : 'a t -> key -> (key -> 'a) -> 'a
            val structural_descr : Structural_descr.t -> Structural_descr.t
            val make_type : 'Type.t -> 'a t Type.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
        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 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
        val from_map : 'a map -> t
        val fold2_join_heterogeneous :
          cache:Hptmap_sig.cache_type ->
          empty_left:('a map -> 'b) ->
          empty_right:(t -> 'b) ->
          both:(elt -> '-> 'b) ->
          join:('-> '-> 'b) -> empty:'-> t -> 'a map -> 'b
        val replace : elt map -> t -> bool * t
        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