functor   (E : 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 of_string : string -> t          val to_string : t -> string          val of_singleton_string : string -> Parameter_sig.Set.t        end) (X : sig                    val option_name : string                    val help : string                    val arg_name : string                    val dependencies : State.t list                    val default : E.Set.t                  end->   sig     type t = E.Set.t     val set : t -> unit     val add_set_hook : (t -> t -> unit) -> unit     val add_update_hook : (t -> t -> unit) -> unit     val get : unit -> t     val clear : unit -> unit     val is_default : unit -> bool     val option_name : string     val print_help : Format.formatter -> unit     val self : State.t     val name : string     val mark_as_computed : ?project:Project.t -> unit -> unit     val is_computed : ?project:Project.t -> unit -> bool     module Datatype : Datatype.S     val add_hook_on_update : (Datatype.t -> unit) -> unit     val howto_marshal : (Datatype.t -> 'a) -> ('-> Datatype.t) -> unit     val equal : t -> t -> bool     val add_aliases : string list -> unit     val is_set : unit -> bool     val unsafe_set : t -> unit     val parameter : Typed_parameter.t     type elt = E.t     val is_empty : unit -> bool     val iter : (elt -> unit) -> unit     val fold : (elt -> '-> 'a) -> '-> 'a     val add : elt -> unit     module As_string : String     module Category :       sig         type elt = elt         type t = elt Parameter_category.t         val none : t         val default : unit -> t         val all : unit -> t         val set_default : t -> unit         val add :           string -> State.t list -> elt Parameter_category.accessor -> t         val enable_all : State.t list -> elt Parameter_category.accessor -> t         val enable_all_as : t -> unit       end     val mem : elt -> bool     val exists : (elt -> bool) -> bool   end