functor   (Elt : Element) (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 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 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 = Elt.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) (Functor_info : Datatype.Functor_info->   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     type elt = Elt.t     val pair : elt -> elt -> t Equality_sig.trivial     val mem : elt -> t -> bool     val add : elt -> t -> t     val remove : elt -> t -> t Equality_sig.trivial     val union : t -> t -> t     val inter : t -> t -> t Equality_sig.trivial     val intersects : t -> t -> bool     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 Equality_sig.trivial     val cardinal : t -> int     val choose : t -> elt     module Set :       sig         type element = elt         type equality = t         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         val empty : t         val is_empty : t -> bool         val add : equality -> t -> t         val singleton : equality -> t         val union : t -> t -> t         val inter : t -> t -> t         val compare : t -> t -> int         val equal : t -> t -> bool         val subset : t -> t -> bool         val iter : (equality -> unit) -> t -> unit         val fold : (equality -> '-> 'a) -> t -> '-> 'a         val for_all : (equality -> bool) -> t -> bool         val exists : (equality -> bool) -> t -> bool         val elements : t -> equality list         val choose : t -> equality         val remove : element -> t -> t         val unite : element -> element -> t -> t         val find : element -> t -> equality         val find_option : element -> t -> equality option         val mem : equality -> t -> bool         val contains : element -> t -> bool         val deep_fold : (equality -> element -> '-> 'a) -> t -> '-> 'a         val cardinal : t -> int         val elements_only_left : t -> t -> element Equality_sig.tree       end   end