2009-06-26 07:53:31 -06:00
|
|
|
|
# Definitions related to run-time type checking. Used in particular
|
|
|
|
|
# to type-check NixOS configurations.
|
2017-07-28 18:05:35 -06:00
|
|
|
|
{ lib }:
|
|
|
|
|
with lib.lists;
|
|
|
|
|
with lib.attrsets;
|
|
|
|
|
with lib.options;
|
|
|
|
|
with lib.trivial;
|
|
|
|
|
with lib.strings;
|
|
|
|
|
let
|
|
|
|
|
|
2018-07-20 13:36:12 -06:00
|
|
|
|
inherit (lib.modules) mergeDefinitions;
|
2017-07-28 18:05:35 -06:00
|
|
|
|
outer_types =
|
2015-03-12 16:01:47 -06:00
|
|
|
|
rec {
|
2013-03-13 08:05:30 -06:00
|
|
|
|
isType = type: x: (x._type or "") == type;
|
2009-06-26 07:53:31 -06:00
|
|
|
|
|
2009-11-19 10:19:39 -07:00
|
|
|
|
setType = typeName: value: value // {
|
|
|
|
|
_type = typeName;
|
|
|
|
|
};
|
|
|
|
|
|
2011-06-13 20:41:13 -06:00
|
|
|
|
|
2016-09-06 19:03:32 -06:00
|
|
|
|
# Default type merging function
|
|
|
|
|
# takes two type functors and return the merged type
|
|
|
|
|
defaultTypeMerge = f: f':
|
|
|
|
|
let wrapped = f.wrapped.typeMerge f'.wrapped.functor;
|
|
|
|
|
payload = f.binOp f.payload f'.payload;
|
|
|
|
|
in
|
|
|
|
|
# cannot merge different types
|
|
|
|
|
if f.name != f'.name
|
|
|
|
|
then null
|
|
|
|
|
# simple types
|
|
|
|
|
else if (f.wrapped == null && f'.wrapped == null)
|
|
|
|
|
&& (f.payload == null && f'.payload == null)
|
|
|
|
|
then f.type
|
|
|
|
|
# composed types
|
|
|
|
|
else if (f.wrapped != null && f'.wrapped != null) && (wrapped != null)
|
|
|
|
|
then f.type wrapped
|
|
|
|
|
# value types
|
|
|
|
|
else if (f.payload != null && f'.payload != null) && (payload != null)
|
|
|
|
|
then f.type payload
|
|
|
|
|
else null;
|
|
|
|
|
|
|
|
|
|
# Default type functor
|
|
|
|
|
defaultFunctor = name: {
|
|
|
|
|
inherit name;
|
|
|
|
|
type = types."${name}" or null;
|
|
|
|
|
wrapped = null;
|
|
|
|
|
payload = null;
|
|
|
|
|
binOp = a: b: null;
|
|
|
|
|
};
|
|
|
|
|
|
2013-03-13 08:05:30 -06:00
|
|
|
|
isOptionType = isType "option-type";
|
2009-06-26 07:53:31 -06:00
|
|
|
|
mkOptionType =
|
2016-09-06 19:03:32 -06:00
|
|
|
|
{ # Human-readable representation of the type, should be equivalent to
|
|
|
|
|
# the type function name.
|
2013-10-28 12:48:30 -06:00
|
|
|
|
name
|
2017-04-19 13:41:28 -06:00
|
|
|
|
, # Description of the type, defined recursively by embedding the wrapped type if any.
|
2016-09-06 19:03:32 -06:00
|
|
|
|
description ? null
|
2013-10-28 12:48:30 -06:00
|
|
|
|
, # Function applied to each definition that should return true if
|
|
|
|
|
# its type-correct, false otherwise.
|
|
|
|
|
check ? (x: true)
|
|
|
|
|
, # Merge a list of definitions together into a single value.
|
2013-10-30 07:21:41 -06:00
|
|
|
|
# This function is called with two arguments: the location of
|
|
|
|
|
# the option in the configuration as a list of strings
|
|
|
|
|
# (e.g. ["boot" "loader "grub" "enable"]), and a list of
|
|
|
|
|
# definition values and locations (e.g. [ { file = "/foo.nix";
|
|
|
|
|
# value = 1; } { file = "/bar.nix"; value = 2 } ]).
|
2013-10-28 12:48:30 -06:00
|
|
|
|
merge ? mergeDefaultOption
|
2016-03-01 12:47:08 -07:00
|
|
|
|
, # Return a flat list of sub-options. Used to generate
|
|
|
|
|
# documentation.
|
|
|
|
|
getSubOptions ? prefix: {}
|
2014-08-29 08:42:44 -06:00
|
|
|
|
, # List of modules if any, or null if none.
|
|
|
|
|
getSubModules ? null
|
2016-09-06 19:03:32 -06:00
|
|
|
|
, # Function for building the same option type with a different list of
|
2014-08-29 08:42:44 -06:00
|
|
|
|
# modules.
|
|
|
|
|
substSubModules ? m: null
|
2016-09-06 19:03:32 -06:00
|
|
|
|
, # Function that merge type declarations.
|
|
|
|
|
# internal, takes a functor as argument and returns the merged type.
|
|
|
|
|
# returning null means the type is not mergeable
|
|
|
|
|
typeMerge ? defaultTypeMerge functor
|
|
|
|
|
, # The type functor.
|
|
|
|
|
# internal, representation of the type as an attribute set.
|
|
|
|
|
# name: name of the type
|
|
|
|
|
# type: type function.
|
|
|
|
|
# wrapped: the type wrapped in case of compound types.
|
2017-03-11 15:39:40 -07:00
|
|
|
|
# payload: values of the type, two payloads of the same type must be
|
2016-09-06 19:03:32 -06:00
|
|
|
|
# combinable with the binOp binary operation.
|
|
|
|
|
# binOp: binary operation that merge two payloads of the same type.
|
|
|
|
|
functor ? defaultFunctor name
|
2009-06-26 07:53:31 -06:00
|
|
|
|
}:
|
|
|
|
|
{ _type = "option-type";
|
2016-09-06 19:03:32 -06:00
|
|
|
|
inherit name check merge getSubOptions getSubModules substSubModules typeMerge functor;
|
|
|
|
|
description = if description == null then name else description;
|
2009-06-26 07:53:31 -06:00
|
|
|
|
};
|
|
|
|
|
|
2011-06-13 20:41:13 -06:00
|
|
|
|
|
2017-05-24 06:51:01 -06:00
|
|
|
|
# When adding new types don't forget to document them in
|
|
|
|
|
# nixos/doc/manual/development/option-types.xml!
|
2009-11-06 18:58:56 -07:00
|
|
|
|
types = rec {
|
2013-10-27 17:56:22 -06:00
|
|
|
|
unspecified = mkOptionType {
|
|
|
|
|
name = "unspecified";
|
|
|
|
|
};
|
|
|
|
|
|
2009-06-26 07:53:31 -06:00
|
|
|
|
bool = mkOptionType {
|
2016-09-06 19:03:32 -06:00
|
|
|
|
name = "bool";
|
|
|
|
|
description = "boolean";
|
2013-11-12 05:48:19 -07:00
|
|
|
|
check = isBool;
|
2015-06-15 10:04:27 -06:00
|
|
|
|
merge = mergeEqualOption;
|
2009-06-26 07:53:31 -06:00
|
|
|
|
};
|
|
|
|
|
|
2017-10-31 05:48:37 -06:00
|
|
|
|
int = mkOptionType rec {
|
|
|
|
|
name = "int";
|
|
|
|
|
description = "signed integer";
|
|
|
|
|
check = isInt;
|
2019-07-25 09:12:15 -06:00
|
|
|
|
merge = mergeEqualOption;
|
2017-10-31 05:48:37 -06:00
|
|
|
|
};
|
2017-08-05 07:06:48 -06:00
|
|
|
|
|
2017-11-03 05:20:35 -06:00
|
|
|
|
# Specialized subdomains of int
|
2017-08-05 07:06:48 -06:00
|
|
|
|
ints =
|
|
|
|
|
let
|
|
|
|
|
betweenDesc = lowest: highest:
|
2017-08-05 07:13:55 -06:00
|
|
|
|
"${toString lowest} and ${toString highest} (both inclusive)";
|
2018-08-05 17:36:09 -06:00
|
|
|
|
between = lowest: highest:
|
|
|
|
|
assert lib.assertMsg (lowest <= highest)
|
|
|
|
|
"ints.between: lowest must be smaller than highest";
|
2017-08-05 07:06:48 -06:00
|
|
|
|
addCheck int (x: x >= lowest && x <= highest) // {
|
|
|
|
|
name = "intBetween";
|
2017-10-31 10:08:32 -06:00
|
|
|
|
description = "integer between ${betweenDesc lowest highest}";
|
2017-08-05 07:06:48 -06:00
|
|
|
|
};
|
|
|
|
|
ign = lowest: highest: name: docStart:
|
|
|
|
|
between lowest highest // {
|
|
|
|
|
inherit name;
|
2017-10-31 10:08:32 -06:00
|
|
|
|
description = docStart + "; between ${betweenDesc lowest highest}";
|
2017-08-05 07:06:48 -06:00
|
|
|
|
};
|
|
|
|
|
unsign = bit: range: ign 0 (range - 1)
|
2017-10-31 10:08:32 -06:00
|
|
|
|
"unsignedInt${toString bit}" "${toString bit} bit unsigned integer";
|
2017-08-05 07:06:48 -06:00
|
|
|
|
sign = bit: range: ign (0 - (range / 2)) (range / 2 - 1)
|
2017-10-31 10:08:32 -06:00
|
|
|
|
"signedInt${toString bit}" "${toString bit} bit signed integer";
|
2017-08-05 07:06:48 -06:00
|
|
|
|
|
|
|
|
|
in rec {
|
2017-08-05 07:13:55 -06:00
|
|
|
|
/* An int with a fixed range.
|
2017-08-05 07:06:48 -06:00
|
|
|
|
*
|
|
|
|
|
* Example:
|
|
|
|
|
* (ints.between 0 100).check (-1)
|
|
|
|
|
* => false
|
|
|
|
|
* (ints.between 0 100).check (101)
|
|
|
|
|
* => false
|
|
|
|
|
* (ints.between 0 0).check 0
|
|
|
|
|
* => true
|
|
|
|
|
*/
|
|
|
|
|
inherit between;
|
|
|
|
|
|
|
|
|
|
unsigned = addCheck types.int (x: x >= 0) // {
|
|
|
|
|
name = "unsignedInt";
|
|
|
|
|
description = "unsigned integer, meaning >=0";
|
|
|
|
|
};
|
2017-10-31 10:30:15 -06:00
|
|
|
|
positive = addCheck types.int (x: x > 0) // {
|
|
|
|
|
name = "positiveInt";
|
|
|
|
|
description = "positive integer, meaning >0";
|
|
|
|
|
};
|
2017-10-31 05:48:37 -06:00
|
|
|
|
u8 = unsign 8 256;
|
|
|
|
|
u16 = unsign 16 65536;
|
2017-11-05 13:47:09 -07:00
|
|
|
|
# the biggest int a 64-bit Nix accepts is 2^63 - 1 (9223372036854775808), for a 32-bit Nix it is 2^31 - 1 (2147483647)
|
|
|
|
|
# the smallest int a 64-bit Nix accepts is -2^63 (-9223372036854775807), for a 32-bit Nix it is -2^31 (-2147483648)
|
|
|
|
|
# u32 = unsign 32 4294967296;
|
|
|
|
|
# u64 = unsign 64 18446744073709551616;
|
2017-08-05 07:06:48 -06:00
|
|
|
|
|
2017-10-31 05:48:37 -06:00
|
|
|
|
s8 = sign 8 256;
|
|
|
|
|
s16 = sign 16 65536;
|
2017-11-05 13:47:09 -07:00
|
|
|
|
# s32 = sign 32 4294967296;
|
2017-07-08 06:10:22 -06:00
|
|
|
|
};
|
|
|
|
|
|
2018-10-18 15:39:13 -06:00
|
|
|
|
# Alias of u16 for a port number
|
|
|
|
|
port = ints.u16;
|
|
|
|
|
|
2018-06-30 13:13:49 -06:00
|
|
|
|
float = mkOptionType rec {
|
|
|
|
|
name = "float";
|
|
|
|
|
description = "floating point number";
|
|
|
|
|
check = isFloat;
|
2019-07-25 09:12:15 -06:00
|
|
|
|
merge = mergeEqualOption;
|
2018-06-30 13:13:49 -06:00
|
|
|
|
};
|
|
|
|
|
|
2013-10-29 06:45:30 -06:00
|
|
|
|
str = mkOptionType {
|
2016-09-06 19:03:32 -06:00
|
|
|
|
name = "str";
|
|
|
|
|
description = "string";
|
2013-11-12 05:48:19 -07:00
|
|
|
|
check = isString;
|
2019-07-25 09:12:15 -06:00
|
|
|
|
merge = mergeEqualOption;
|
2013-10-29 06:45:30 -06:00
|
|
|
|
};
|
|
|
|
|
|
2017-12-02 11:04:16 -07:00
|
|
|
|
strMatching = pattern: mkOptionType {
|
|
|
|
|
name = "strMatching ${escapeNixString pattern}";
|
|
|
|
|
description = "string matching the pattern ${pattern}";
|
|
|
|
|
check = x: str.check x && builtins.match pattern x != null;
|
|
|
|
|
inherit (str) merge;
|
|
|
|
|
};
|
|
|
|
|
|
2013-10-30 07:21:41 -06:00
|
|
|
|
# Merge multiple definitions by concatenating them (with the given
|
|
|
|
|
# separator between the values).
|
2016-09-06 19:03:32 -06:00
|
|
|
|
separatedString = sep: mkOptionType rec {
|
|
|
|
|
name = "separatedString";
|
2018-10-11 19:23:11 -06:00
|
|
|
|
description = if sep == ""
|
|
|
|
|
then "Concatenated string" # for types.string.
|
|
|
|
|
else "strings concatenated with ${builtins.toJSON sep}"
|
|
|
|
|
;
|
2013-11-12 05:48:19 -07:00
|
|
|
|
check = isString;
|
2016-03-01 12:47:08 -07:00
|
|
|
|
merge = loc: defs: concatStringsSep sep (getValues defs);
|
2016-09-06 19:03:32 -06:00
|
|
|
|
functor = (defaultFunctor name) // {
|
|
|
|
|
payload = sep;
|
|
|
|
|
binOp = sepLhs: sepRhs:
|
|
|
|
|
if sepLhs == sepRhs then sepLhs
|
|
|
|
|
else null;
|
|
|
|
|
};
|
2013-02-11 07:28:41 -07:00
|
|
|
|
};
|
|
|
|
|
|
2016-03-01 12:47:08 -07:00
|
|
|
|
lines = separatedString "\n";
|
|
|
|
|
commas = separatedString ",";
|
|
|
|
|
envVar = separatedString ":";
|
2013-10-28 09:14:15 -06:00
|
|
|
|
|
2013-10-30 07:21:41 -06:00
|
|
|
|
# Deprecated; should not be used because it quietly concatenates
|
|
|
|
|
# strings, which is usually not what you want.
|
2019-08-31 10:19:15 -06:00
|
|
|
|
string = warn "types.string is deprecated because it quietly concatenates strings"
|
|
|
|
|
(separatedString "");
|
2009-11-06 18:58:56 -07:00
|
|
|
|
|
2009-06-26 07:53:31 -06:00
|
|
|
|
attrs = mkOptionType {
|
2016-09-06 19:03:32 -06:00
|
|
|
|
name = "attrs";
|
|
|
|
|
description = "attribute set";
|
2013-10-27 17:56:22 -06:00
|
|
|
|
check = isAttrs;
|
2016-03-01 12:47:08 -07:00
|
|
|
|
merge = loc: foldl' (res: def: mergeAttrs res def.value) {};
|
2009-06-26 07:53:31 -06:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
# derivation is a reserved keyword.
|
|
|
|
|
package = mkOptionType {
|
2016-02-17 12:24:22 -07:00
|
|
|
|
name = "package";
|
2015-08-06 11:55:42 -06:00
|
|
|
|
check = x: isDerivation x || isStorePath x;
|
2016-03-01 12:47:08 -07:00
|
|
|
|
merge = loc: defs:
|
|
|
|
|
let res = mergeOneOption loc defs;
|
2015-08-06 11:55:42 -06:00
|
|
|
|
in if isDerivation res then res else toDerivation res;
|
2009-06-26 07:53:31 -06:00
|
|
|
|
};
|
|
|
|
|
|
2016-06-12 13:03:14 -06:00
|
|
|
|
shellPackage = package // {
|
|
|
|
|
check = x: (package.check x) && (hasAttr "shellPath" x);
|
|
|
|
|
};
|
|
|
|
|
|
2012-05-25 11:19:07 -06:00
|
|
|
|
path = mkOptionType {
|
|
|
|
|
name = "path";
|
|
|
|
|
# Hacky: there is no ‘isPath’ primop.
|
2015-08-15 07:38:12 -06:00
|
|
|
|
check = x: builtins.substring 0 1 (toString x) == "/";
|
2019-07-25 09:12:15 -06:00
|
|
|
|
merge = mergeEqualOption;
|
2012-05-25 11:19:07 -06:00
|
|
|
|
};
|
|
|
|
|
|
2013-08-22 00:45:22 -06:00
|
|
|
|
# drop this in the future:
|
2017-11-03 05:20:35 -06:00
|
|
|
|
list = builtins.trace "`types.list` is deprecated; use `types.listOf` instead" types.listOf;
|
2013-08-22 00:45:22 -06:00
|
|
|
|
|
2016-09-06 19:03:32 -06:00
|
|
|
|
listOf = elemType: mkOptionType rec {
|
|
|
|
|
name = "listOf";
|
|
|
|
|
description = "list of ${elemType.description}s";
|
2014-05-01 15:58:16 -06:00
|
|
|
|
check = isList;
|
2016-03-01 12:47:08 -07:00
|
|
|
|
merge = loc: defs:
|
2017-07-04 16:29:23 -06:00
|
|
|
|
map (x: x.value) (filter (x: x ? value) (concatLists (imap1 (n: def:
|
2016-05-25 03:02:38 -06:00
|
|
|
|
if isList def.value then
|
2017-07-04 16:29:23 -06:00
|
|
|
|
imap1 (m: def':
|
2016-05-25 03:02:38 -06:00
|
|
|
|
(mergeDefinitions
|
|
|
|
|
(loc ++ ["[definition ${toString n}-entry ${toString m}]"])
|
|
|
|
|
elemType
|
|
|
|
|
[{ inherit (def) file; value = def'; }]
|
|
|
|
|
).optionalValue
|
|
|
|
|
) def.value
|
|
|
|
|
else
|
2017-11-03 05:20:35 -06:00
|
|
|
|
throw "The option value `${showOption loc}` in `${def.file}` is not a list.") defs)));
|
2016-03-01 12:47:08 -07:00
|
|
|
|
getSubOptions = prefix: elemType.getSubOptions (prefix ++ ["*"]);
|
2014-08-29 08:42:44 -06:00
|
|
|
|
getSubModules = elemType.getSubModules;
|
|
|
|
|
substSubModules = m: listOf (elemType.substSubModules m);
|
2016-09-06 19:03:32 -06:00
|
|
|
|
functor = (defaultFunctor name) // { wrapped = elemType; };
|
2009-06-26 07:53:31 -06:00
|
|
|
|
};
|
|
|
|
|
|
2018-04-04 08:55:45 -06:00
|
|
|
|
nonEmptyListOf = elemType:
|
2018-02-08 01:49:06 -07:00
|
|
|
|
let list = addCheck (types.listOf elemType) (l: l != []);
|
|
|
|
|
in list // { description = "non-empty " + list.description; };
|
|
|
|
|
|
2016-09-06 19:03:32 -06:00
|
|
|
|
attrsOf = elemType: mkOptionType rec {
|
|
|
|
|
name = "attrsOf";
|
|
|
|
|
description = "attribute set of ${elemType.description}s";
|
2014-05-01 16:13:06 -06:00
|
|
|
|
check = isAttrs;
|
2016-03-01 12:47:08 -07:00
|
|
|
|
merge = loc: defs:
|
2014-05-01 16:13:06 -06:00
|
|
|
|
mapAttrs (n: v: v.value) (filterAttrs (n: v: v ? value) (zipAttrsWith (name: defs:
|
2016-03-01 12:47:08 -07:00
|
|
|
|
(mergeDefinitions (loc ++ [name]) elemType defs).optionalValue
|
2015-03-12 16:01:47 -06:00
|
|
|
|
)
|
2013-10-30 07:21:41 -06:00
|
|
|
|
# Push down position info.
|
2019-01-26 08:34:40 -07:00
|
|
|
|
(map (def: mapAttrs (n: v: { inherit (def) file; value = v; }) def.value) defs)));
|
2016-03-01 12:47:08 -07:00
|
|
|
|
getSubOptions = prefix: elemType.getSubOptions (prefix ++ ["<name>"]);
|
2014-08-29 08:42:44 -06:00
|
|
|
|
getSubModules = elemType.getSubModules;
|
|
|
|
|
substSubModules = m: attrsOf (elemType.substSubModules m);
|
2016-09-06 19:03:32 -06:00
|
|
|
|
functor = (defaultFunctor name) // { wrapped = elemType; };
|
2009-06-26 07:53:31 -06:00
|
|
|
|
};
|
|
|
|
|
|
2011-06-13 20:41:13 -06:00
|
|
|
|
# List or attribute set of ...
|
|
|
|
|
loaOf = elemType:
|
|
|
|
|
let
|
2018-03-24 10:38:45 -06:00
|
|
|
|
convertAllLists = defs:
|
|
|
|
|
let
|
|
|
|
|
padWidth = stringLength (toString (length defs));
|
|
|
|
|
unnamedPrefix = i: "unnamed-" + fixedWidthNumber padWidth i + ".";
|
|
|
|
|
in
|
|
|
|
|
imap1 (i: convertIfList (unnamedPrefix i)) defs;
|
|
|
|
|
|
|
|
|
|
convertIfList = unnamedPrefix: def:
|
2013-10-30 07:21:41 -06:00
|
|
|
|
if isList def.value then
|
2018-03-24 10:38:45 -06:00
|
|
|
|
let
|
|
|
|
|
padWidth = stringLength (toString (length def.value));
|
|
|
|
|
unnamed = i: unnamedPrefix + fixedWidthNumber padWidth i;
|
|
|
|
|
in
|
|
|
|
|
{ inherit (def) file;
|
|
|
|
|
value = listToAttrs (
|
|
|
|
|
imap1 (elemIdx: elem:
|
|
|
|
|
{ name = elem.name or (unnamed elemIdx);
|
|
|
|
|
value = elem;
|
|
|
|
|
}) def.value);
|
|
|
|
|
}
|
2011-06-13 20:41:13 -06:00
|
|
|
|
else
|
|
|
|
|
def;
|
|
|
|
|
attrOnly = attrsOf elemType;
|
2016-09-06 19:03:32 -06:00
|
|
|
|
in mkOptionType rec {
|
|
|
|
|
name = "loaOf";
|
|
|
|
|
description = "list or attribute set of ${elemType.description}s";
|
2014-05-01 18:17:03 -06:00
|
|
|
|
check = x: isList x || isAttrs x;
|
2018-03-24 10:38:45 -06:00
|
|
|
|
merge = loc: defs: attrOnly.merge loc (convertAllLists defs);
|
2016-03-01 12:47:08 -07:00
|
|
|
|
getSubOptions = prefix: elemType.getSubOptions (prefix ++ ["<name?>"]);
|
2014-08-29 08:42:44 -06:00
|
|
|
|
getSubModules = elemType.getSubModules;
|
|
|
|
|
substSubModules = m: loaOf (elemType.substSubModules m);
|
2016-09-06 19:03:32 -06:00
|
|
|
|
functor = (defaultFunctor name) // { wrapped = elemType; };
|
2013-10-27 17:56:22 -06:00
|
|
|
|
};
|
2011-06-13 20:41:13 -06:00
|
|
|
|
|
2017-05-25 10:18:34 -06:00
|
|
|
|
# Value of given type but with no merging (i.e. `uniq list`s are not concatenated).
|
2016-09-06 19:03:32 -06:00
|
|
|
|
uniq = elemType: mkOptionType rec {
|
|
|
|
|
name = "uniq";
|
|
|
|
|
inherit (elemType) description check;
|
2013-10-28 12:48:30 -06:00
|
|
|
|
merge = mergeOneOption;
|
2013-10-28 07:25:58 -06:00
|
|
|
|
getSubOptions = elemType.getSubOptions;
|
2014-08-29 08:42:44 -06:00
|
|
|
|
getSubModules = elemType.getSubModules;
|
|
|
|
|
substSubModules = m: uniq (elemType.substSubModules m);
|
2016-09-06 19:03:32 -06:00
|
|
|
|
functor = (defaultFunctor name) // { wrapped = elemType; };
|
2009-06-26 07:53:31 -06:00
|
|
|
|
};
|
|
|
|
|
|
2017-05-25 10:18:34 -06:00
|
|
|
|
# Null or value of ...
|
2016-09-06 19:03:32 -06:00
|
|
|
|
nullOr = elemType: mkOptionType rec {
|
|
|
|
|
name = "nullOr";
|
|
|
|
|
description = "null or ${elemType.description}";
|
2015-12-03 21:22:57 -07:00
|
|
|
|
check = x: x == null || elemType.check x;
|
2016-03-01 12:47:08 -07:00
|
|
|
|
merge = loc: defs:
|
2015-12-03 21:22:57 -07:00
|
|
|
|
let nrNulls = count (def: def.value == null) defs; in
|
2013-10-30 07:21:41 -06:00
|
|
|
|
if nrNulls == length defs then null
|
|
|
|
|
else if nrNulls != 0 then
|
2017-11-03 05:20:35 -06:00
|
|
|
|
throw "The option `${showOption loc}` is defined both null and not null, in ${showFiles (getFiles defs)}."
|
2016-03-01 12:47:08 -07:00
|
|
|
|
else elemType.merge loc defs;
|
2013-10-28 07:25:58 -06:00
|
|
|
|
getSubOptions = elemType.getSubOptions;
|
2014-08-29 08:42:44 -06:00
|
|
|
|
getSubModules = elemType.getSubModules;
|
|
|
|
|
substSubModules = m: nullOr (elemType.substSubModules m);
|
2016-09-06 19:03:32 -06:00
|
|
|
|
functor = (defaultFunctor name) // { wrapped = elemType; };
|
2009-06-26 07:53:31 -06:00
|
|
|
|
};
|
|
|
|
|
|
2017-05-25 10:18:34 -06:00
|
|
|
|
# A submodule (like typed attribute set). See NixOS manual.
|
2014-02-13 10:08:05 -07:00
|
|
|
|
submodule = opts:
|
2013-10-30 12:12:25 -06:00
|
|
|
|
let
|
|
|
|
|
opts' = toList opts;
|
2017-07-28 18:05:35 -06:00
|
|
|
|
inherit (lib.modules) evalModules;
|
2013-10-30 12:12:25 -06:00
|
|
|
|
in
|
2013-10-28 07:25:58 -06:00
|
|
|
|
mkOptionType rec {
|
|
|
|
|
name = "submodule";
|
2013-11-12 05:48:19 -07:00
|
|
|
|
check = x: isAttrs x || isFunction x;
|
2016-03-01 12:47:08 -07:00
|
|
|
|
merge = loc: defs:
|
2013-10-28 07:25:58 -06:00
|
|
|
|
let
|
2013-11-12 05:48:19 -07:00
|
|
|
|
coerce = def: if isFunction def then def else { config = def; };
|
2016-03-01 12:47:08 -07:00
|
|
|
|
modules = opts' ++ map (def: { _file = def.file; imports = [(coerce def.value)]; }) defs;
|
2014-05-05 14:30:51 -06:00
|
|
|
|
in (evalModules {
|
|
|
|
|
inherit modules;
|
2016-03-01 12:47:08 -07:00
|
|
|
|
args.name = last loc;
|
2014-05-05 14:30:51 -06:00
|
|
|
|
prefix = loc;
|
|
|
|
|
}).config;
|
2016-03-01 12:47:08 -07:00
|
|
|
|
getSubOptions = prefix: (evalModules
|
|
|
|
|
{ modules = opts'; inherit prefix;
|
2017-10-30 05:17:06 -06:00
|
|
|
|
# This is a work-around due to the fact that some sub-modules,
|
|
|
|
|
# such as the one included in an attribute set, expects a "args"
|
|
|
|
|
# attribute to be given to the sub-module. As the option
|
|
|
|
|
# evaluation does not have any specific attribute name, we
|
|
|
|
|
# provide a default one for the documentation.
|
|
|
|
|
#
|
|
|
|
|
# This is mandatory as some option declaration might use the
|
|
|
|
|
# "name" attribute given as argument of the submodule and use it
|
|
|
|
|
# as the default of option declarations.
|
2018-05-16 10:11:36 -06:00
|
|
|
|
#
|
|
|
|
|
# Using lookalike unicode single angle quotation marks because
|
|
|
|
|
# of the docbook transformation the options receive. In all uses
|
|
|
|
|
# > and < wouldn't be encoded correctly so the encoded values
|
|
|
|
|
# would be used, and use of `<` and `>` would break the XML document.
|
|
|
|
|
# It shouldn't cause an issue since this is cosmetic for the manual.
|
|
|
|
|
args.name = "‹name›";
|
2017-10-30 05:17:06 -06:00
|
|
|
|
}).options;
|
2014-08-29 08:42:44 -06:00
|
|
|
|
getSubModules = opts';
|
|
|
|
|
substSubModules = m: submodule m;
|
2016-09-06 19:03:32 -06:00
|
|
|
|
functor = (defaultFunctor name) // {
|
|
|
|
|
# Merging of submodules is done as part of mergeOptionDecls, as we have to annotate
|
|
|
|
|
# each submodule with its location.
|
|
|
|
|
payload = [];
|
|
|
|
|
binOp = lhs: rhs: [];
|
|
|
|
|
};
|
2013-10-28 07:25:58 -06:00
|
|
|
|
};
|
2013-10-27 17:56:22 -06:00
|
|
|
|
|
2017-05-25 10:18:34 -06:00
|
|
|
|
# A value from a set of allowed ones.
|
2016-03-01 12:47:08 -07:00
|
|
|
|
enum = values:
|
|
|
|
|
let
|
|
|
|
|
show = v:
|
|
|
|
|
if builtins.isString v then ''"${v}"''
|
|
|
|
|
else if builtins.isInt v then builtins.toString v
|
|
|
|
|
else ''<${builtins.typeOf v}>'';
|
|
|
|
|
in
|
2016-09-06 19:03:32 -06:00
|
|
|
|
mkOptionType rec {
|
|
|
|
|
name = "enum";
|
|
|
|
|
description = "one of ${concatMapStringsSep ", " show values}";
|
2016-03-01 12:47:08 -07:00
|
|
|
|
check = flip elem values;
|
2019-07-25 09:12:15 -06:00
|
|
|
|
merge = mergeEqualOption;
|
2016-09-06 19:03:32 -06:00
|
|
|
|
functor = (defaultFunctor name) // { payload = values; binOp = a: b: unique (a ++ b); };
|
2016-03-01 12:47:08 -07:00
|
|
|
|
};
|
2014-05-01 09:30:20 -06:00
|
|
|
|
|
2017-05-25 10:18:34 -06:00
|
|
|
|
# Either value of type `t1` or `t2`.
|
2016-09-06 19:03:32 -06:00
|
|
|
|
either = t1: t2: mkOptionType rec {
|
|
|
|
|
name = "either";
|
|
|
|
|
description = "${t1.description} or ${t2.description}";
|
2016-03-01 12:47:08 -07:00
|
|
|
|
check = x: t1.check x || t2.check x;
|
2016-11-06 16:34:06 -07:00
|
|
|
|
merge = loc: defs:
|
|
|
|
|
let
|
|
|
|
|
defList = map (d: d.value) defs;
|
|
|
|
|
in
|
|
|
|
|
if all (x: t1.check x) defList
|
|
|
|
|
then t1.merge loc defs
|
|
|
|
|
else if all (x: t2.check x) defList
|
|
|
|
|
then t2.merge loc defs
|
|
|
|
|
else mergeOneOption loc defs;
|
2016-09-06 19:03:32 -06:00
|
|
|
|
typeMerge = f':
|
|
|
|
|
let mt1 = t1.typeMerge (elemAt f'.wrapped 0).functor;
|
|
|
|
|
mt2 = t2.typeMerge (elemAt f'.wrapped 1).functor;
|
|
|
|
|
in
|
|
|
|
|
if (name == f'.name) && (mt1 != null) && (mt2 != null)
|
|
|
|
|
then functor.type mt1 mt2
|
|
|
|
|
else null;
|
|
|
|
|
functor = (defaultFunctor name) // { wrapped = [ t1 t2 ]; };
|
2016-03-01 12:47:08 -07:00
|
|
|
|
};
|
2014-08-19 05:13:51 -06:00
|
|
|
|
|
2019-08-01 07:55:33 -06:00
|
|
|
|
# Any of the types in the given list
|
|
|
|
|
oneOf = ts:
|
|
|
|
|
let
|
|
|
|
|
head' = if ts == [] then throw "types.oneOf needs to get at least one type in its argument" else head ts;
|
|
|
|
|
tail' = tail ts;
|
|
|
|
|
in foldl' either head' tail';
|
|
|
|
|
|
2017-05-25 10:18:34 -06:00
|
|
|
|
# Either value of type `finalType` or `coercedType`, the latter is
|
|
|
|
|
# converted to `finalType` using `coerceFunc`.
|
2017-01-13 18:14:01 -07:00
|
|
|
|
coercedTo = coercedType: coerceFunc: finalType:
|
2018-08-08 11:26:52 -06:00
|
|
|
|
assert lib.assertMsg (coercedType.getSubModules == null)
|
2018-08-05 17:36:09 -06:00
|
|
|
|
"coercedTo: coercedType must not have submodules (it’s a ${
|
|
|
|
|
coercedType.description})";
|
2017-01-13 18:14:01 -07:00
|
|
|
|
mkOptionType rec {
|
|
|
|
|
name = "coercedTo";
|
2018-04-04 08:55:45 -06:00
|
|
|
|
description = "${finalType.description} or ${coercedType.description} convertible to it";
|
2018-03-09 05:41:55 -07:00
|
|
|
|
check = x: finalType.check x || (coercedType.check x && finalType.check (coerceFunc x));
|
2017-01-13 18:14:01 -07:00
|
|
|
|
merge = loc: defs:
|
|
|
|
|
let
|
|
|
|
|
coerceVal = val:
|
|
|
|
|
if finalType.check val then val
|
2018-04-04 09:40:47 -06:00
|
|
|
|
else coerceFunc val;
|
2017-01-13 18:14:01 -07:00
|
|
|
|
in finalType.merge loc (map (def: def // { value = coerceVal def.value; }) defs);
|
|
|
|
|
getSubOptions = finalType.getSubOptions;
|
|
|
|
|
getSubModules = finalType.getSubModules;
|
|
|
|
|
substSubModules = m: coercedTo coercedType coerceFunc (finalType.substSubModules m);
|
|
|
|
|
typeMerge = t1: t2: null;
|
|
|
|
|
functor = (defaultFunctor name) // { wrapped = finalType; };
|
|
|
|
|
};
|
|
|
|
|
|
2013-10-27 17:56:22 -06:00
|
|
|
|
# Obsolete alternative to configOf. It takes its option
|
|
|
|
|
# declarations from the ‘options’ attribute of containing option
|
|
|
|
|
# declaration.
|
2019-03-07 12:28:09 -07:00
|
|
|
|
optionSet = mkOptionType {
|
|
|
|
|
name = builtins.trace "types.optionSet is deprecated; use types.submodule instead" "optionSet";
|
|
|
|
|
description = "option set";
|
|
|
|
|
};
|
2013-10-30 08:33:20 -06:00
|
|
|
|
# Augment the given type with an additional type check function.
|
|
|
|
|
addCheck = elemType: check: elemType // { check = x: elemType.check x && check x; };
|
|
|
|
|
|
2009-06-26 07:53:31 -06:00
|
|
|
|
};
|
2017-07-28 18:05:35 -06:00
|
|
|
|
};
|
2009-06-26 07:53:31 -06:00
|
|
|
|
|
2017-07-28 18:05:35 -06:00
|
|
|
|
in outer_types // outer_types.types
|