lib.options: NixOS / nixpkgs option handling

lib.options.isOption

Type: isOption :: a -> bool

Returns true when the given argument is an option

isOption 1             // => false
isOption (mkOption {}) // => true

Located at lib/options.nix:56 in <nixpkgs>.

lib.options.mkOption

Creates an Option attribute set. mkOption accepts an attribute set with the following keys:

All keys default to null when not given.

structured function argument

: default

Default value used when no definition is given in the configuration.

defaultText

Textual representation of the default, for the manual.

example

Example value used in the manual.

description

String describing the option.

relatedPackages

Related packages used in the manual (see genRelatedPackages in ../nixos/lib/make-options-doc/default.nix).

type

Option type, providing type-checking and value merging.

apply

Function that converts the option value to something else.

internal

Whether the option is for NixOS developers only.

visible

Whether the option shows up in the manual. Default: true. Use false to hide the option and any sub-options from submodules. Use "shallow" to hide only sub-options.

readOnly

Whether the option can be set only once

mkOption { }  // => { _type = "option"; }
mkOption { default = "foo"; } // => { _type = "option"; default = "foo"; }

Located at lib/options.nix:66 in <nixpkgs>.

lib.options.mkEnableOption

Creates an Option attribute set for a boolean value option i.e an option to be toggled on or off:

name

Name for the created option

mkEnableOption "foo"
=> { _type = "option"; default = false; description = "Whether to enable foo."; example = true; type = { ... }; }

Located at lib/options.nix:98 in <nixpkgs>.

lib.options.mkPackageOption

Type: mkPackageOption :: pkgs -> (string|[string]) -> { default? :: [string], example? :: null|string|[string], extraDescription? :: string } -> option

Creates an Option attribute set for an option that specifies the package a module should use for some purpose.

The package is specified in the third argument under default as a list of strings representing its attribute path in nixpkgs (or another package set). Because of this, you need to pass nixpkgs itself (or a subset) as the first argument.

The second argument may be either a string or a list of strings. It provides the display name of the package in the description of the generated option (using only the last element if the passed value is a list) and serves as the fallback value for the default argument.

To include extra information in the description, pass extraDescription to append arbitrary text to the generated description. You can also pass an example value, either a literal string or an attribute path.

The default argument can be omitted if the provided name is an attribute of pkgs (if name is a string) or a valid attribute path in pkgs (if name is a list).

If you wish to explicitly provide no default, pass null as default.

pkgs

Package set (a specific version of nixpkgs or a subset)

name

Name for the package, shown in option description

structured function argument

: nullable

Whether the package can be null, for example to disable installing a package altogether.

default

The attribute path where the default package is located (may be omitted)

example

A string or an attribute path to use as an example (may be omitted)

extraDescription

Additional text to include in the option description (may be omitted)

mkPackageOption pkgs "hello" { }
=> { _type = "option"; default = «derivation /nix/store/3r2vg51hlxj3cx5vscp0vkv60bqxkaq0-hello-2.10.drv»; defaultText = { ... }; description = "The hello package to use."; type = { ... }; }


mkPackageOption pkgs "GHC" {
  default = [ "ghc" ];
  example = "pkgs.haskell.packages.ghc92.ghc.withPackages (hkgs: [ hkgs.primes ])";
}
=> { _type = "option"; default = «derivation /nix/store/jxx55cxsjrf8kyh3fp2ya17q99w7541r-ghc-8.10.7.drv»; defaultText = { ... }; description = "The GHC package to use."; example = { ... }; type = { ... }; }


mkPackageOption pkgs [ "python39Packages" "pytorch" ] {
  extraDescription = "This is an example and doesn't actually do anything.";
}
=> { _type = "option"; default = «derivation /nix/store/gvqgsnc4fif9whvwd9ppa568yxbkmvk8-python3.9-pytorch-1.10.2.drv»; defaultText = { ... }; description = "The pytorch package to use. This is an example and doesn't actually do anything."; type = { ... }; }

Located at lib/options.nix:149 in <nixpkgs>.

lib.options.mkPackageOptionMD

Alias of mkPackageOption. Previously used to create options with markdown documentation, which is no longer required.

Located at lib/options.nix:188 in <nixpkgs>.

lib.options.mkSinkUndeclaredOptions

This option accepts anything, but it does not produce any result.

This is useful for sharing a module across different module sets without having to implement similar features as long as the values of the options are not accessed.

attrs

Function argument

Located at lib/options.nix:195 in <nixpkgs>.

lib.options.mergeEqualOption

"Merge" option definitions by checking that they all have the same value.

loc

Function argument

defs

Function argument

Located at lib/options.nix:228 in <nixpkgs>.

lib.options.getValues

Type: getValues :: [ { value :: a; } ] -> [a]

Extracts values of all "value" keys of the given list.

getValues [ { value = 1; } { value = 2; } ] // => [ 1 2 ]
getValues [ ]                               // => [ ]

Located at lib/options.nix:248 in <nixpkgs>.

lib.options.getFiles

Type: getFiles :: [ { file :: a; } ] -> [a]

Extracts values of all "file" keys of the given list

getFiles [ { file = "file1"; } { file = "file2"; } ] // => [ "file1" "file2" ]
getFiles [ ]                                         // => [ ]

Located at lib/options.nix:258 in <nixpkgs>.

lib.options.scrubOptionValue

This function recursively removes all derivation attributes from x except for the name attribute.

This is to make the generation of options.xml much more efficient: the XML representation of derivations is very large (on the order of megabytes) and is not actually used by the manual generator.

This function was made obsolete by renderOptionValue and is kept for compatibility with out-of-tree code.

x

Function argument

Located at lib/options.nix:316 in <nixpkgs>.

lib.options.renderOptionValue

Ensures that the given option value (default or example) is a _typed string by rendering Nix values to literalExpressions.

v

Function argument

Located at lib/options.nix:327 in <nixpkgs>.

lib.options.literalExpression

For use in the defaultText and example option attributes. Causes the given string to be rendered verbatim in the documentation as Nix code. This is necessary for complex values, e.g. functions, or values that depend on other values or packages.

text

Function argument

Located at lib/options.nix:340 in <nixpkgs>.

lib.options.mdDoc

Transition marker for documentation that's already migrated to markdown syntax. This is a no-op and no longer needed.

Located at lib/options.nix:349 in <nixpkgs>.

lib.options.literalMD

For use in the defaultText and example option attributes. Causes the given MD text to be inserted verbatim in the documentation, for when a literalExpression would be too hard to read.

text

Function argument

Located at lib/options.nix:355 in <nixpkgs>.

lib.options.showOption

Convert an option, described as a list of the option parts to a human-readable version.

parts

Function argument

(showOption ["foo" "bar" "baz"]) == "foo.bar.baz"
  (showOption ["foo" "bar.baz" "tux"]) == "foo.\"bar.baz\".tux"
  (showOption ["windowManager" "2bwm" "enable"]) == "windowManager.\"2bwm\".enable"

Placeholders will not be quoted as they are not actual values:
  (showOption ["foo" "*" "bar"]) == "foo.*.bar"
  (showOption ["foo" "<name>" "bar"]) == "foo.<name>.bar"

Located at lib/options.nix:373 in <nixpkgs>.