functor   (K : String_datatype_with_collections) (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                                                 type key = K.t                                                 val of_string :                                                   key:key ->                                                   prev:t option ->                                                   string option -> t option                                                 val to_string :                                                   key:key ->                                                   t option -> string option                                               end) (X : sig                                                           val option_name :                                                             string                                                           val help : string                                                           val arg_name :                                                             string                                                           val dependencies :                                                             State.t list                                                           val default :                                                             V.t K.Map.t                                                         end->   sig     type key = K.t     type value = V.t     type t = V.t K.Map.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 = key * value option     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 find : key -> value     val mem : key -> bool   end