sig   module type Element =     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       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       val id : t -> int       val self : State.t       val pretty_debug : t Pretty_utils.formatter     end   module Make :     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 end