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 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 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