functor
  (K : Key) (Top_Param : sig
                           module O :
                             sig
                               type elt = K.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 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
                           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) (V : 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 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
                                     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 diff : t -> t -> t
                                     val diff_if_one : t -> t -> t
                                     val fold_enum :
                                       (t -> '-> 'a) -> t -> '-> 'a
                                     val cardinal_less_than : t -> int -> int
                                     exception Error_Top
                                     val pretty_debug :
                                       t Pretty_utils.formatter
                                   end) (Comp : sig
                                                  val e : bool
                                                  val f : K.t -> V.t -> bool
                                                  val compose :
                                                    bool -> bool -> bool
                                                  val default : bool
                                                end) (L : sig
                                                            val v :
                                                              (K.t * V.t)
                                                              list list
                                                          end->
  sig
    module M :
      sig
        type key = K.t
        type t = Make_without_cardinal(K)(Top_Param)(V)(Comp)(L).M.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 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 = Make_without_cardinal(K)(Top_Param)(V)(Comp)(L).M.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 =
                'Make_without_cardinal(K)(Top_Param)(V)(Comp)(L).M.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 =
                'a
                Make_without_cardinal(K)(Top_Param)(V)(Comp)(L).M.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
        val self : State.t
        val empty : t
        val hash : t -> int
        val is_empty : t -> bool
        val add : key -> V.t -> t -> t
        val find : key -> t -> V.t
        val find_check_missing : key -> t -> V.t
        val find_key : key -> t -> key
        val remove : key -> t -> t
        val mem : key -> t -> bool
        val iter : (K.t -> V.t -> unit) -> t -> unit
        val map : (V.t -> V.t) -> t -> t
        val map' : (K.t -> V.t -> V.t option) -> t -> t
        val fold : (K.t -> V.t -> '-> 'b) -> t -> '-> 'b
        val fold_rev : (K.t -> V.t -> '-> 'b) -> t -> '-> 'b
        val for_all : (K.t -> V.t -> bool) -> t -> bool
        val exists : (K.t -> V.t -> bool) -> t -> bool
        val generic_merge :
          cache:string * bool ->
          decide:(K.t -> V.t option -> V.t option -> V.t) ->
          idempotent:bool -> empty_neutral:bool -> t -> t -> t
        val symmetric_merge :
          cache:string * '->
          empty_neutral:bool ->
          decide_none:(K.t -> V.t -> V.t) ->
          decide_some:(V.t -> V.t -> V.t) -> t -> t -> t
        val symmetric_inter :
          cache:string * '->
          decide_some:(K.t -> V.t -> V.t -> V.t option) -> t -> t -> t
        val inter_with_shape : 'Hptmap.Shape(K).t -> t -> t
        type decide_fast =
          Make_without_cardinal(K)(Top_Param)(V)(Comp)(L).M.decide_fast =
            Done
          | Unknown
        val generic_predicate :
          exn ->
          cache:string * '->
          decide_fast:(t -> t -> decide_fast) ->
          decide_fst:(K.t -> V.t -> unit) ->
          decide_snd:(K.t -> V.t -> unit) ->
          decide_both:(V.t -> V.t -> unit) -> t -> t -> unit
        type predicate_type =
          Make_without_cardinal(K)(Top_Param)(V)(Comp)(L).M.predicate_type =
            ExistentialPredicate
          | UniversalPredicate
        type predicate_result =
          Make_without_cardinal(K)(Top_Param)(V)(Comp)(L).M.predicate_result =
            PTrue
          | PFalse
          | PUnknown
        val binary_predicate :
          Hptmap.cache_type ->
          predicate_type ->
          decide_fast:(t -> t -> predicate_result) ->
          decide_fst:(K.t -> V.t -> bool) ->
          decide_snd:(K.t -> V.t -> bool) ->
          decide_both:(K.t -> V.t -> V.t -> bool) -> t -> t -> bool
        val generic_symmetric_predicate :
          exn ->
          decide_fast:(t -> t -> decide_fast) ->
          decide_one:(K.t -> V.t -> unit) ->
          decide_both:(V.t -> V.t -> unit) -> t -> t -> unit
        val symmetric_binary_predicate :
          Hptmap.cache_type ->
          predicate_type ->
          decide_fast:(t -> t -> predicate_result) ->
          decide_one:(K.t -> V.t -> bool) ->
          decide_both:(K.t -> V.t -> V.t -> bool) -> t -> t -> bool
        val decide_fast_inclusion : t -> t -> predicate_result
        val decide_fast_intersection : t -> t -> predicate_result
        val cached_fold :
          cache_name:string ->
          temporary:bool ->
          f:(key -> V.t -> 'b) ->
          joiner:('-> '-> 'b) -> empty:'-> t -> 'b
        val cached_map :
          cache:string * int ->
          temporary:bool -> f:(key -> V.t -> V.t) -> t -> t
        val singleton : key -> V.t -> t
        val is_singleton : t -> (key * V.t) option
        val cardinal : t -> int
        val min_binding : t -> key * V.t
        val max_binding : t -> key * V.t
        val split : key -> t -> t * V.t option * t
        val compositional_bool : t -> bool
        val clear_caches : unit -> unit
        val from_shape : (K.t -> '-> V.t) -> 'Hptmap.Shape(K).t -> t
        val shape : t -> V.t Hptmap.Shape(K).t
        val fold2_join_heterogeneous :
          cache:Hptmap.cache_type ->
          empty_left:('Hptmap.Shape(K).t -> 'b) ->
          empty_right:(t -> 'b) ->
          both:(K.t -> V.t -> '-> 'b) ->
          join:('-> '-> 'b) ->
          empty:'-> t -> 'Hptmap.Shape(K).t -> 'b
        val hash_debug : t -> int
        val pretty_debug : Format.formatter -> t -> unit
        val comp_prefixes : t -> t -> unit
        val pretty_prefix : Hptmap.prefix -> Format.formatter -> t -> unit
        type subtree =
            Make_without_cardinal(K)(Top_Param)(V)(Comp)(L).M.subtree
        exception Found_prefix of Hptmap.prefix * subtree * subtree
        val find_prefix : t -> Hptmap.prefix -> subtree option
        val hash_subtree : subtree -> int
        val equal_subtree : subtree -> subtree -> bool
      end
    module Top_Param :
      sig
        module O :
          sig
            type elt = K.t
            type t = Top_Param.O.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 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
        exception Error_Top
        type t = Top_Param.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
    type map_t = M.t
    type tt =
      Make_without_cardinal(K)(Top_Param)(V)(Comp)(L).tt =
        Top of Top_Param.t * Origin.t
      | Map of map_t
    val top : tt
    val add_or_bottom : M.key -> V.t -> M.t -> M.t
    val add : Top_Param.O.elt -> V.t -> tt -> tt
    val bottom : tt
    val inject : M.key -> V.t -> tt
    val pretty_debug : Format.formatter -> tt -> unit
    val find_or_bottom : M.key -> M.t -> V.t
    val split : Top_Param.O.elt -> tt -> V.t * tt
    val inject_map : map_t -> tt
    val get_bases : M.t -> Top_Param.O.t
    exception Error_Top
    val is_bottom : tt -> bool
    val check_join_assert : int ref
    val join : tt -> tt -> tt
    val cached_fold :
      cache_name:string ->
      temporary:bool ->
      f:(M.key -> V.t -> 'a) ->
      projection:(M.key -> V.t) ->
      joiner:('-> '-> 'a) -> empty:'-> tt -> 'a
    val map_offsets : (V.t -> V.t) -> tt -> tt
    val filter_base : (Top_Param.O.elt -> bool) -> tt -> tt
    val meet : tt -> tt -> tt
    val narrow : tt -> tt -> tt
    val is_included : tt -> tt -> bool
    val join_and_is_included : tt -> tt -> tt * bool
    val link : tt -> tt -> tt
    val intersects : tt -> tt -> bool
    val find_lonely_key : tt -> M.key * V.t
    val diff : tt -> tt -> tt
    val map_i : (K.t -> V.t -> tt) -> tt -> tt
    val fold_bases : (Top_Param.O.elt -> '-> 'a) -> tt -> '-> 'a
    val fold_i : (K.t -> V.t -> '-> 'a) -> tt -> '-> 'a
    val fold_topset_ok :
      (Top_Param.O.elt -> V.t -> '-> 'a) -> tt -> '-> 'a
    type t = tt
    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 = Make_without_cardinal(K)(Top_Param)(V)(Comp)(L).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 = 'Make_without_cardinal(K)(Top_Param)(V)(Comp)(L).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 =
            'Make_without_cardinal(K)(Top_Param)(V)(Comp)(L).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
    val clear_caches : unit -> unit
    type widen_hint = K.t -> V.widen_hint
    val widen : (K.t -> V.widen_hint) -> tt -> tt -> tt
    val find_lonely_binding : tt -> M.key * V.t
    val cardinal_zero_or_one : t -> bool
    val cardinal_less_than : tt -> int -> int
    val fold_enum : (tt -> '-> 'a) -> tt -> '-> 'a
    val diff_if_one : tt -> tt -> tt
  end