Throw if pred is false, else return pred. Intended to be used to augment asserts with helpful error messages.

assertMsg false "nope"
stderr> error: nope

assert assertMsg ("foo" == "bar") "foo is not bar, silly"; ""
stderr> error: foo is not bar, silly

Located at lib/asserts.nix:19 in <nixpkgs>.

Specialized `assertMsg` for checking if `val` is one of the elements of the list `xs`. Useful for checking enums.

let sslLibrary = "libressl";
in assertOneOf "sslLibrary" sslLibrary [ "openssl" "bearssl" ]
stderr> error: sslLibrary must be one of [
stderr>   "openssl"
stderr>   "bearssl"
stderr> ], but is: "libressl"

Located at lib/asserts.nix:40 in <nixpkgs>.

Return an attribute from nested attribute sets.

x = { a = { b = 3; }; }
# ["a" "b"] is equivalent to x.a.b
# 6 is a default value to return if the path does not exist in attrset
attrByPath ["a" "b"] 6 x
=> 3
attrByPath ["z" "z"] 6 x
=> 6

Located at lib/attrsets.nix:30 in <nixpkgs>.

Return if an attribute from nested attribute set exists.

x = { a = { b = 3; }; }
hasAttrByPath ["a" "b"] x
=> true
hasAttrByPath ["z" "z"] x
=> false

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

Create a new attribute set with `value` set at the nested attribute location specified in `attrPath`.

setAttrByPath ["a" "b"] 3
=> { a = { b = 3; }; }

Located at lib/attrsets.nix:78 in <nixpkgs>.

Like `attrByPath`, but without a default value. If it doesn't find the path it will throw an error.

x = { a = { b = 3; }; }
getAttrFromPath ["a" "b"] x
=> 3
getAttrFromPath ["z" "z"] x
=> error: cannot find attribute `z.z'

Located at lib/attrsets.nix:104 in <nixpkgs>.

Map each attribute in the given set and merge them into a new attribute set.

concatMapAttrs
(name: value: {
${name} = value;
${name + value} = value;
})
{ x = "a"; y = "b"; }
=> { x = "a"; xa = "a"; y = "b"; yb = "b"; }

Located at lib/attrsets.nix:126 in <nixpkgs>.

Update or set specific paths of an attribute set.

Takes a list of updates to apply and an attribute set to apply them to, and returns the attribute set with the updates applied. Updates are represented as `{ path = ...; update = ...; }` values, where `path` is a list of strings representing the attribute path that should be updated, and `update` is a function that takes the old value at that attribute path as an argument and returns the new value it should be.

Properties:

- Updates to deeper attribute paths are applied before updates to more shallow attribute paths

- Multiple updates to the same attribute path are applied in the order they appear in the update list

- If any but the last `path` element leads into a value that is not an attribute set, an error is thrown

- If there is an update for an attribute path that doesn't exist, accessing the argument in the update function causes an error, but intermediate attribute sets are implicitly created as needed

updateManyAttrsByPath [
{
path = [ "a" "b" ];
update = old: { d = old.c; };
}
{
path = [ "a" "b" "c" ];
update = old: old + 1;
}
{
path = [ "x" "y" ];
update = old: "xy";
}
] { a.b.c = 0; }
=> { a = { b = { d = 1; }; }; x = { y = "xy"; }; }

Located at lib/attrsets.nix:173 in <nixpkgs>.

Return the specified attributes from a set.

attrVals ["a" "b" "c"] as
=> [as.a as.b as.c]

Located at lib/attrsets.nix:241 in <nixpkgs>.

Return the values of all attributes in the given set, sorted by attribute name.

attrValues {c = 3; a = 1; b = 2;}
=> [1 2 3]

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

Given a set of attribute names, return the set of the corresponding attributes from the given set.

getAttrs [ "a" "b" ] { a = 1; b = 2; c = 3; }
=> { a = 1; b = 2; }

Located at lib/attrsets.nix:271 in <nixpkgs>.

Collect each attribute named `attr` from a list of attribute sets. Sets that don't contain the named attribute are ignored.

catAttrs "a" [{a = 1;} {b = 0;} {a = 2;}]
=> [1 2]

Located at lib/attrsets.nix:287 in <nixpkgs>.

Filter an attribute set by removing all attributes for which the given predicate return false.

filterAttrs (n: v: n == "foo") { foo = 1; bar = 2; }
=> { foo = 1; }

Located at lib/attrsets.nix:301 in <nixpkgs>.

Filter an attribute set recursively by removing all attributes for which the given predicate return false.

filterAttrsRecursive (n: v: v != null) { foo = { bar = null; }; }
=> { foo = {}; }

Located at lib/attrsets.nix:319 in <nixpkgs>.

Like builtins.foldl' but for attribute sets. Iterates over every name-value pair in the given attribute set. The result of the callback function is often called `acc` for accumulator. It is passed between callbacks from left to right and the final `acc` is the return value of `foldlAttrs`.

Attention: There is a completely different function `lib.foldAttrs` which has nothing to do with this function, despite the similar name.

foldlAttrs
(acc: name: value: {
sum = acc.sum + value;
names = acc.names ++ [name];
})
{ sum = 0; names = []; }
{
foo = 1;
bar = 10;
}
->
{
sum = 11;
names = ["bar" "foo"];
}

foldlAttrs
(throw "function not needed")
123
{};
->
123

foldlAttrs
(_: _: v: v)
(throw "initial accumulator not needed")
{ z = 3; a = 2; };
->
3

The accumulator doesn't have to be an attrset.
It can be as simple as a number or string.

foldlAttrs
(acc: _: v: acc * 10 + v)
1
{ z = 1; a = 2; };
->
121

Located at lib/attrsets.nix:390 in <nixpkgs>.

Apply fold functions to values grouped by key.

foldAttrs (item: acc: [item] ++ acc) [] [{ a = 2; } { a = 3; }]
=> { a = [ 2 3 ]; }

Located at lib/attrsets.nix:406 in <nixpkgs>.

Recursively collect sets that verify a given predicate named `pred` from the set `attrs`. The recursion is stopped when the predicate is verified.

collect isList { a = { b = ["b"]; }; c = [1]; }
=> [["b"] [1]]

collect (x: x ? outPath)
{ a = { outPath = "a/"; }; b = { outPath = "b/"; }; }
=> [{ outPath = "a/"; } { outPath = "b/"; }]

Located at lib/attrsets.nix:435 in <nixpkgs>.

Return the cartesian product of attribute set value combinations.

cartesianProductOfSets { a = [ 1 2 ]; b = [ 10 20 ]; }
=> [
{ a = 1; b = 10; }
{ a = 1; b = 20; }
{ a = 2; b = 10; }
{ a = 2; b = 20; }
]

Located at lib/attrsets.nix:460 in <nixpkgs>.

Utility function that creates a `{name, value}` pair as expected by `builtins.listToAttrs`.

nameValuePair "some" 6
=> { name = "some"; value = 6; }

Located at lib/attrsets.nix:479 in <nixpkgs>.

Apply a function to each element in an attribute set, creating a new attribute set.

mapAttrs (name: value: name + "-" + value)
{ x = "foo"; y = "bar"; }
=> { x = "x-foo"; y = "y-bar"; }

Located at lib/attrsets.nix:497 in <nixpkgs>.

Like `mapAttrs`, but allows the name of each attribute to be changed in addition to the value. The applied function should return both the new name and value as a `nameValuePair`.

mapAttrs' (name: value: nameValuePair ("foo_" + name) ("bar-" + value))
{ x = "a"; y = "b"; }
=> { foo_x = "bar-a"; foo_y = "bar-b"; }

Located at lib/attrsets.nix:514 in <nixpkgs>.

Call a function for each attribute in the given set and return the result in a list.

mapAttrsToList (name: value: name + value)
{ x = "a"; y = "b"; }
=> [ "xa" "yb" ]

Located at lib/attrsets.nix:534 in <nixpkgs>.

Like `mapAttrs`, except that it recursively applies itself to the *leaf* attributes of a potentially-nested attribute set: the second argument of the function will never be an attrset. Also, the first argument of the argument function is a *list* of the attribute names that form the path to the leaf attribute.

For a function that gives you control over what counts as a leaf, see `mapAttrsRecursiveCond`.

mapAttrsRecursive (path: value: concatStringsSep "-" (path ++ [value]))
{ n = { a = "A"; m = { b = "B"; c = "C"; }; }; d = "D"; }
=> { n = { a = "n-a-A"; m = { b = "n-m-b-B"; c = "n-m-c-C"; }; }; d = "d-D"; }

Located at lib/attrsets.nix:559 in <nixpkgs>.

Like `mapAttrsRecursive`, but it takes an additional predicate function that tells it whether to recurse into an attribute set. If it returns false, `mapAttrsRecursiveCond` does not recurse, but does apply the map function. If it returns true, it does recurse, and does not apply the map function.

# To prevent recursing into derivations (which are attribute
# sets with the attribute "type" equal to "derivation"):
mapAttrsRecursiveCond
(as: !(as ? "type" && as.type == "derivation"))
(x: ... do something ...)
attrs

Located at lib/attrsets.nix:584 in <nixpkgs>.

Generate an attribute set by mapping a function over a list of attribute names.

genAttrs [ "foo" "bar" ] (name: "x_" + name)
=> { foo = "x_foo"; bar = "x_bar"; }

Located at lib/attrsets.nix:613 in <nixpkgs>.

Check whether the argument is a derivation. Any set with `{ type = "derivation"; }` counts as a derivation.

nixpkgs = import <nixpkgs> {}
isDerivation nixpkgs.ruby
=> true
isDerivation "foobar"
=> false

Located at lib/attrsets.nix:634 in <nixpkgs>.

Converts a store path to a fake derivation.

Located at lib/attrsets.nix:643 in <nixpkgs>.

If `cond` is true, return the attribute set `as`, otherwise an empty attribute set.

optionalAttrs (true) { my = "set"; }
=> { my = "set"; }
optionalAttrs (false) { my = "set"; }
=> { }

Located at lib/attrsets.nix:671 in <nixpkgs>.

Merge sets of attributes and use the function `f` to merge attributes values.

zipAttrsWithNames ["a"] (name: vs: vs) [{a = "x";} {a = "y"; b = "z";}]
=> { a = ["x" "y"]; }

Located at lib/attrsets.nix:689 in <nixpkgs>.

Merge sets of attributes and use the function f to merge attribute values. Like `lib.attrsets.zipAttrsWithNames` with all key names are passed for `names`.

Implementation note: Common names appear multiple times in the list of names, hopefully this does not affect the system because the maximal laziness avoid computing twice the same expression and `listToAttrs` does not care about duplicated attribute names.

zipAttrsWith (name: values: values) [{a = "x";} {a = "y"; b = "z";}]
=> { a = ["x" "y"]; b = ["z"]; }

Located at lib/attrsets.nix:717 in <nixpkgs>.

Merge sets of attributes and combine each attribute value in to a list.

Like `lib.attrsets.zipAttrsWith` with `(name: values: values)` as the function.

zipAttrs [{a = "x";} {a = "y"; b = "z";}]
=> { a = ["x" "y"]; b = ["z"]; }

Located at lib/attrsets.nix:732 in <nixpkgs>.

Does the same as the update operator '//' except that attributes are merged until the given predicate is verified. The predicate should accept 3 arguments which are the path to reach the attribute, a part of the first attribute set and a part of the second attribute set. When the predicate is satisfied, the value of the first attribute set is replaced by the value of the second attribute set.

recursiveUpdateUntil (path: l: r: path == ["foo"]) {
# first attribute set
foo.bar = 1;
foo.baz = 2;
bar = 3;
} {
#second attribute set
foo.bar = 1;
foo.quz = 2;
baz = 4;
}

=> {
foo.bar = 1; # 'foo.*' from the second set
foo.quz = 2; #
bar = 3;     # 'bar' from the first set
baz = 4;     # 'baz' from the second set
}

Located at lib/attrsets.nix:768 in <nixpkgs>.

A recursive variant of the update operator ‘//’. The recursion stops when one of the attribute values is not an attribute set, in which case the right hand side value takes precedence over the left hand side value.

recursiveUpdate {
boot.loader.grub.enable = true;
boot.loader.grub.device = "/dev/hda";
} {
boot.loader.grub.device = "";
}

returns: {
boot.loader.grub.enable = true;
boot.loader.grub.device = "";
}

Located at lib/attrsets.nix:808 in <nixpkgs>.

Returns true if the pattern is contained in the set. False otherwise.

matchAttrs { cpu = {}; } { cpu = { bits = 64; }; }
=> true

Located at lib/attrsets.nix:825 in <nixpkgs>.

Override only the attributes that are already present in the old set useful for deep-overriding.

overrideExisting {} { a = 1; }
=> {}
overrideExisting { b = 2; } { a = 1; }
=> { b = 2; }
overrideExisting { a = 3; b = 2; } { a = 1; }
=> { a = 1; b = 2; }

Located at lib/attrsets.nix:853 in <nixpkgs>.

Turns a list of strings into a human-readable description of those strings represented as an attribute path. The result of this function is not intended to be machine-readable. Create a new attribute set with `value` set at the nested attribute location specified in `attrPath`.

showAttrPath [ "foo" "10" "bar" ]
=> "foo.\"10\".bar"
showAttrPath []
=> "<root attribute path>"

Located at lib/attrsets.nix:875 in <nixpkgs>.

Get a package output. If no output is found, fallback to `.out` and then to the default.

getOutput "dev" pkgs.openssl
=> "/nix/store/9rz8gxhzf8sw4kf2j2f1grr49w8zx5vj-openssl-1.0.1r-dev"

Located at lib/attrsets.nix:892 in <nixpkgs>.

Get a package's `bin` output. If the output does not exist, fallback to `.out` and then to the default.

getBin pkgs.openssl
=> "/nix/store/9rz8gxhzf8sw4kf2j2f1grr49w8zx5vj-openssl-1.0.1r"

Located at lib/attrsets.nix:907 in <nixpkgs>.

Get a package's `lib` output. If the output does not exist, fallback to `.out` and then to the default.

getLib pkgs.openssl
=> "/nix/store/9rz8gxhzf8sw4kf2j2f1grr49w8zx5vj-openssl-1.0.1r-lib"

Located at lib/attrsets.nix:920 in <nixpkgs>.

Get a package's `dev` output. If the output does not exist, fallback to `.out` and then to the default.

getDev pkgs.openssl
=> "/nix/store/9rz8gxhzf8sw4kf2j2f1grr49w8zx5vj-openssl-1.0.1r-dev"

Located at lib/attrsets.nix:933 in <nixpkgs>.

Get a package's `man` output. If the output does not exist, fallback to `.out` and then to the default.

getMan pkgs.openssl
=> "/nix/store/9rz8gxhzf8sw4kf2j2f1grr49w8zx5vj-openssl-1.0.1r-man"

Located at lib/attrsets.nix:946 in <nixpkgs>.

Pick the outputs of packages to place in `buildInputs`

Located at lib/attrsets.nix:953 in <nixpkgs>.

Make various Nix tools consider the contents of the resulting attribute set when looking for what to build, find, etc.

This function only affects a single attribute set; it does not apply itself recursively for nested attribute sets.

{ pkgs ? import <nixpkgs> {} }:
{
myTools = pkgs.lib.recurseIntoAttrs {
inherit (pkgs) hello figlet;
};
}

Located at lib/attrsets.nix:976 in <nixpkgs>.

Undo the effect of recurseIntoAttrs.

Located at lib/attrsets.nix:986 in <nixpkgs>.

`unionOfDisjoint x y` is equal to `x // y // z` where the attrnames in `z` are the intersection of the attrnames in `x` and `y`, and all values `assert` with an error message. This operator is commutative, unlike (//).

Located at lib/attrsets.nix:998 in <nixpkgs>.

Concatenate a list of strings.

concatStrings ["foo" "bar"]
=> "foobar"

Located at lib/strings.nix:47 in <nixpkgs>.

Map a function over a list and concatenate the resulting strings.

concatMapStrings (x: "a" + x) ["foo" "bar"]
=> "afooabar"

Located at lib/strings.nix:57 in <nixpkgs>.

Like `concatMapStrings` except that the f functions also gets the position as a parameter.

concatImapStrings (pos: x: "${toString pos}-${x}") ["foo" "bar"]
=> "1-foo2-bar"

Located at lib/strings.nix:68 in <nixpkgs>.

Place an element between each element of a list

intersperse "/" ["usr" "local" "bin"]
=> ["usr" "/" "local" "/" "bin"].

Located at lib/strings.nix:78 in <nixpkgs>.

Concatenate a list of strings with a separator between each element

concatStringsSep "/" ["usr" "local" "bin"]
=> "usr/local/bin"

Located at lib/strings.nix:95 in <nixpkgs>.

Maps a function over a list of strings and then concatenates the result with the specified separator interspersed between elements.

concatMapStringsSep "-" (x: toUpper x)  ["foo" "bar" "baz"]
=> "FOO-BAR-BAZ"

Located at lib/strings.nix:108 in <nixpkgs>.

Same as `concatMapStringsSep`, but the mapping function additionally receives the position of its argument.

concatImapStringsSep "-" (pos: x: toString (x / pos)) [ 6 6 6 ]
=> "6-3-2"

Located at lib/strings.nix:125 in <nixpkgs>.

Concatenate a list of strings, adding a newline at the end of each one. Defined as `concatMapStrings (s: s + "\n")`.

concatLines [ "foo" "bar" ]
=> "foo\nbar\n"

Located at lib/strings.nix:142 in <nixpkgs>.

Construct a Unix-style, colon-separated search path consisting of the given `subDir` appended to each of the given paths.

makeSearchPath "bin" ["/root" "/usr" "/usr/local"]
=> "/root/bin:/usr/bin:/usr/local/bin"
makeSearchPath "bin" [""]
=> "/bin"

Located at lib/strings.nix:155 in <nixpkgs>.

Construct a Unix-style search path by appending the given `subDir` to the specified `output` of each of the packages. If no output by the given name is found, fallback to `.out` and then to the default.

makeSearchPathOutput "dev" "bin" [ pkgs.openssl pkgs.zlib ]
=> "/nix/store/9rz8gxhzf8sw4kf2j2f1grr49w8zx5vj-openssl-1.0.1r-dev/bin:/nix/store/wwh7mhwh269sfjkm6k5665b5kgp7jrk2-zlib-1.2.8/bin"

Located at lib/strings.nix:173 in <nixpkgs>.

Construct a library search path (such as RPATH) containing the libraries for a set of packages

makeLibraryPath [ "/usr" "/usr/local" ]
=> "/usr/lib:/usr/local/lib"
pkgs = import <nixpkgs> { }
makeLibraryPath [ pkgs.openssl pkgs.zlib ]
=> "/nix/store/9rz8gxhzf8sw4kf2j2f1grr49w8zx5vj-openssl-1.0.1r/lib:/nix/store/wwh7mhwh269sfjkm6k5665b5kgp7jrk2-zlib-1.2.8/lib"

Located at lib/strings.nix:191 in <nixpkgs>.

Construct a binary search path (such as $PATH) containing the binaries for a set of packages.

makeBinPath ["/root" "/usr" "/usr/local"]
=> "/root/bin:/usr/bin:/usr/local/bin"

Located at lib/strings.nix:200 in <nixpkgs>.

Normalize path, removing extraneous /s

normalizePath "/a//b///c/"
=> "/a/b/c/"

Located at lib/strings.nix:210 in <nixpkgs>.

Depending on the boolean `cond', return either the given string or the empty string. Useful to concatenate against a bigger string.

optionalString true "some-string"
=> "some-string"
optionalString false "some-string"
=> ""

Located at lib/strings.nix:223 in <nixpkgs>.

Determine whether a string has given prefix.

hasPrefix "foo" "foobar"
=> true
hasPrefix "foo" "barfoo"
=> false

Located at lib/strings.nix:239 in <nixpkgs>.

Determine whether a string has given suffix.

hasSuffix "foo" "foobar"
=> false
hasSuffix "foo" "barfoo"
=> true

Located at lib/strings.nix:255 in <nixpkgs>.

Determine whether a string contains the given infix

hasInfix "bc" "abcd"
=> true
hasInfix "ab" "abcd"
=> true
hasInfix "cd" "abcd"
=> true
hasInfix "foo" "abcd"
=> false

Located at lib/strings.nix:280 in <nixpkgs>.

Convert a string to a list of characters (i.e. singleton strings). This allows you to, e.g., map a function over each character. However, note that this will likely be horribly inefficient; Nix is not a general purpose programming language. Complex string manipulations should, if appropriate, be done in a derivation. Also note that Nix treats strings as a list of bytes and thus doesn't handle unicode.

stringToCharacters ""
=> [ ]
stringToCharacters "abc"
=> [ "a" "b" "c" ]
stringToCharacters "🦄"
=> [ "�" "�" "�" "�" ]

Located at lib/strings.nix:301 in <nixpkgs>.

Manipulate a string character by character and replace them by strings before concatenating the results.

stringAsChars (x: if x == "a" then "i" else x) "nax"
=> "nix"

Located at lib/strings.nix:313 in <nixpkgs>.

Convert char to ascii value, must be in printable range

charToInt "A"
=> 65
charToInt "("
=> 40

Located at lib/strings.nix:332 in <nixpkgs>.

Escape occurrence of the elements of `list` in `string` by prefixing it with a backslash.

escape ["(" ")"] "(foo)"
=> "\\(foo\\)"

Located at lib/strings.nix:343 in <nixpkgs>.

Escape occurrence of the element of `list` in `string` by converting to its ASCII value and prefixing it with \\x. Only works for printable ascii characters.

escapeC [" "] "foo bar"
=> "foo\\x20bar"

Located at lib/strings.nix:356 in <nixpkgs>.

Escape the string so it can be safely placed inside a URL query.

escapeURL "foo/bar baz"
=> "foo%2Fbar%20baz"

Located at lib/strings.nix:367 in <nixpkgs>.

Quote string to be used safely within the Bourne shell.

escapeShellArg "esc'ape\nme"
=> "'esc'\\''ape\nme'"

Located at lib/strings.nix:381 in <nixpkgs>.

Quote all arguments to be safely passed to the Bourne shell.

escapeShellArgs ["one" "two three" "four'five"]
=> "'one' 'two three' 'four'\\''five'"

Located at lib/strings.nix:391 in <nixpkgs>.

Test whether the given name is a valid POSIX shell variable name.

isValidPosixName "foo_bar000"
=> true
isValidPosixName "0-bad.jpg"
=> false

Located at lib/strings.nix:403 in <nixpkgs>.

Translate a Nix value into a shell variable declaration, with proper escaping.

The value can be a string (mapped to a regular variable), a list of strings (mapped to a Bash-style array) or an attribute set of strings (mapped to a Bash-style associative array). Note that "string" includes string-coercible values like paths or derivations.

Strings are translated into POSIX sh-compatible code; lists and attribute sets assume a shell that understands Bash syntax (e.g. Bash or ZSH).

''
${toShellVar "foo" "some string"}
[[ "$foo" == "some string" ]]
''

Located at lib/strings.nix:423 in <nixpkgs>.

Translate an attribute set into corresponding shell variable declarations using `toShellVar`.

let
foo = "value";
bar = foo;
in ''
${toShellVars { inherit foo bar; }}
[[ "$foo" == "$bar" ]]
''

Located at lib/strings.nix:451 in <nixpkgs>.

Turn a string into a Nix expression representing that string

escapeNixString "hello\${}\n"
=> "\"hello\\\${}\\n\""

Located at lib/strings.nix:461 in <nixpkgs>.

Turn a string into an exact regular expression

escapeRegex "[^a-z]*"
=> "\\[\\^a-z]\\*"

Located at lib/strings.nix:471 in <nixpkgs>.

Quotes a string if it can't be used as an identifier directly.

escapeNixIdentifier "hello"
=> "hello"
escapeNixIdentifier "0abc"
=> "\"0abc\""

Located at lib/strings.nix:483 in <nixpkgs>.

Escapes a string such that it is safe to include verbatim in an XML document.

escapeXML ''"test" 'test' < & >''
=> "&quot;test&quot; &apos;test&apos; &lt; &amp; &gt;"

Located at lib/strings.nix:497 in <nixpkgs>.

Converts an ASCII string to lower-case.

toLower "HOME"
=> "home"

Located at lib/strings.nix:516 in <nixpkgs>.

Converts an ASCII string to upper-case.

toUpper "home"
=> "HOME"

Located at lib/strings.nix:526 in <nixpkgs>.

Appends string context from another string. This is an implementation detail of Nix and should be used carefully.

Strings in Nix carry an invisible `context` which is a list of strings representing store paths. If the string is later used in a derivation attribute, the derivation will properly populate the inputDrvs and inputSrcs.

pkgs = import <nixpkgs> { };
addContextFrom pkgs.coreutils "bar"
=> "bar"

Located at lib/strings.nix:541 in <nixpkgs>.

Cut a string with a separator and produces a list of strings which were separated by this separator.

splitString "." "foo.bar.baz"
=> [ "foo" "bar" "baz" ]
splitString "/" "/usr/local/bin"
=> [ "" "usr" "local" "bin" ]

Located at lib/strings.nix:552 in <nixpkgs>.

Return a string without the specified prefix, if the prefix matches.

removePrefix "foo." "foo.bar.baz"
=> "bar.baz"
removePrefix "xxx" "foo.bar.baz"
=> "foo.bar.baz"

Located at lib/strings.nix:568 in <nixpkgs>.

Return a string without the specified suffix, if the suffix matches.

removeSuffix "front" "homefront"
=> "home"
removeSuffix "xxx" "homefront"
=> "homefront"

Located at lib/strings.nix:592 in <nixpkgs>.

Return true if string v1 denotes a version older than v2.

versionOlder "1.1" "1.2"
=> true
versionOlder "1.1" "1.1"
=> false

Located at lib/strings.nix:614 in <nixpkgs>.

Return true if string v1 denotes a version equal to or newer than v2.

versionAtLeast "1.1" "1.0"
=> true
versionAtLeast "1.1" "1.1"
=> true
versionAtLeast "1.1" "1.2"
=> false

Located at lib/strings.nix:626 in <nixpkgs>.

This function takes an argument that's either a derivation or a derivation's "name" attribute and extracts the name part from that argument.

getName "youtube-dl-2016.01.01"
=> "youtube-dl"
getName pkgs.youtube-dl
=> "youtube-dl"

Located at lib/strings.nix:638 in <nixpkgs>.

This function takes an argument that's either a derivation or a derivation's "name" attribute and extracts the version part from that argument.

getVersion "youtube-dl-2016.01.01"
=> "2016.01.01"
getVersion pkgs.youtube-dl
=> "2016.01.01"

Located at lib/strings.nix:655 in <nixpkgs>.

Extract name with version from URL. Ask for separator which is supposed to start extension.

nameFromURL "https://nixos.org/releases/nix/nix-1.7/nix-1.7-x86_64-linux.tar.bz2" "-"
=> "nix"
nameFromURL "https://nixos.org/releases/nix/nix-1.7/nix-1.7-x86_64-linux.tar.bz2" "_"
=> "nix-1.7-x86"

Located at lib/strings.nix:671 in <nixpkgs>.

Create a -D<feature>=<value> string that can be passed to typical Meson invocations.

mesonOption "engine" "opengl"
=> "-Dengine=opengl"

Located at lib/strings.nix:690 in <nixpkgs>.

Create a -D<condition>={true,false} string that can be passed to typical Meson invocations.

mesonBool "hardened" true
=> "-Dhardened=true"
mesonBool "static" false
=> "-Dstatic=false"

Located at lib/strings.nix:709 in <nixpkgs>.

Create a -D<feature>={enabled,disabled} string that can be passed to typical Meson invocations.

mesonEnable "docs" true
=> "-Ddocs=enabled"
mesonEnable "savage" false
=> "-Dsavage=disabled"

Located at lib/strings.nix:728 in <nixpkgs>.

Create an --{enable,disable}-<feat> string that can be passed to standard GNU Autoconf scripts.

enableFeature true "shared"
=> "--enable-shared"
enableFeature false "shared"
=> "--disable-shared"

Located at lib/strings.nix:742 in <nixpkgs>.

Create an --{enable-<feat>=<value>,disable-<feat>} string that can be passed to standard GNU Autoconf scripts.

enableFeatureAs true "shared" "foo"
=> "--enable-shared=foo"
enableFeatureAs false "shared" (throw "ignored")
=> "--disable-shared"

Located at lib/strings.nix:755 in <nixpkgs>.

Create an --{with,without}-<feat> string that can be passed to standard GNU Autoconf scripts.

withFeature true "shared"
=> "--with-shared"
withFeature false "shared"
=> "--without-shared"

Located at lib/strings.nix:766 in <nixpkgs>.

Create an --{with-<feat>=<value>,without-<feat>} string that can be passed to standard GNU Autoconf scripts.

withFeatureAs true "shared" "foo"
=> "--with-shared=foo"
withFeatureAs false "shared" (throw "ignored")
=> "--without-shared"

Located at lib/strings.nix:779 in <nixpkgs>.

Create a fixed width string with additional prefix to match required width.

This function will fail if the input string is longer than the requested length.

fixedWidthString 5 "0" (toString 15)
=> "00015"

Located at lib/strings.nix:793 in <nixpkgs>.

Format a number adding leading zeroes up to fixed width.

fixedWidthNumber 5 15
=> "00015"

Located at lib/strings.nix:810 in <nixpkgs>.

Convert a float to a string, but emit a warning when precision is lost during the conversion

floatToString 0.000001
=> "0.000001"
floatToString 0.0000001
=> trace: warning: Imprecise conversion from float to string 0.000000
"0.000000"

Located at lib/strings.nix:822 in <nixpkgs>.

Soft-deprecated function. While the original implementation is available as isConvertibleWithToString, consider using isStringLike instead, if suitable.

Located at lib/strings.nix:830 in <nixpkgs>.

Check whether a list or other value can be passed to toString.

Many types of value are coercible to string this way, including int, float, null, bool, list of similarly coercible values.

Located at lib/strings.nix:839 in <nixpkgs>.

Check whether a value can be coerced to a string. The value must be a string, path, or attribute set.

String-like values can be used without explicit conversion in string interpolations and in most functions that expect a string.

Located at lib/strings.nix:850 in <nixpkgs>.

Check whether a value is a store path.

isStorePath "/nix/store/d945ibfx9x185xf04b890y4f9g3cbb63-python-2.7.11/bin/python"
=> false
isStorePath "/nix/store/d945ibfx9x185xf04b890y4f9g3cbb63-python-2.7.11"
=> true
isStorePath pkgs.python
=> true
isStorePath [] || isStorePath 42 || isStorePath {} || …
=> false

Located at lib/strings.nix:868 in <nixpkgs>.

Parse a string as an int. Does not support parsing of integers with preceding zero due to ambiguity between zero-padded and octal numbers. See toIntBase10.

toInt "1337"
=> 1337

toInt "-4"
=> -4

toInt " 123 "
=> 123

toInt "00024"
=> error: Ambiguity in interpretation of 00024 between octal and zero padded integer.

toInt "3.14"
=> error: floating point JSON numbers are not supported

Located at lib/strings.nix:898 in <nixpkgs>.

Parse a string as a base 10 int. This supports parsing of zero-padded integers.

toIntBase10 "1337"
=> 1337

toIntBase10 "-4"
=> -4

toIntBase10 " 123 "
=> 123

toIntBase10 "00024"
=> 24

toIntBase10 "3.14"
=> error: floating point JSON numbers are not supported

Located at lib/strings.nix:949 in <nixpkgs>.

Read a list of paths from `file`, relative to the `rootPath`. Lines beginning with `#` are treated as comments and ignored. Whitespace is significant.

NOTE: This function is not performant and should be avoided.

readPathsFromFile /prefix
./pkgs/development/libraries/qt-5/5.4/qtbase/series
=> [ "/prefix/dlopen-resolv.patch" "/prefix/tzdir.patch"
"/prefix/dlopen-libXcursor.patch" "/prefix/dlopen-openssl.patch"
"/prefix/dlopen-dbus.patch" "/prefix/xdg-config-dirs.patch"
"/prefix/nix-profiles-library-paths.patch"
"/prefix/compose-search-path.patch" ]

Located at lib/strings.nix:992 in <nixpkgs>.

Read the contents of a file removing the trailing \n

$ echo "1.0" > ./version

fileContents ./version
=> "1.0"

Located at lib/strings.nix:1012 in <nixpkgs>.

Creates a valid derivation name from a potentially invalid one.

sanitizeDerivationName "../hello.bar # foo"
=> "-hello.bar-foo"
sanitizeDerivationName ""
=> "unknown"
sanitizeDerivationName pkgs.hello
=> "-nix-store-2g75chlbpxlrqn15zlby2dfh8hr9qwbk-hello-2.10"

Located at lib/strings.nix:1027 in <nixpkgs>.

Computes the Levenshtein distance between two strings. Complexity O(n*m) where n and m are the lengths of the strings. Algorithm adjusted from https://stackoverflow.com/a/9750974/6605742

levenshtein "foo" "foo"
=> 0
levenshtein "book" "hook"
=> 1
levenshtein "hello" "Heyo"
=> 3

Located at lib/strings.nix:1066 in <nixpkgs>.

Returns the length of the prefix common to both strings.

Located at lib/strings.nix:1087 in <nixpkgs>.

Returns the length of the suffix common to both strings.

Located at lib/strings.nix:1095 in <nixpkgs>.

Returns whether the levenshtein distance between two strings is at most some value Complexity is O(min(n,m)) for k <= 2 and O(n*m) otherwise

levenshteinAtMost 0 "foo" "foo"
=> true
levenshteinAtMost 1 "foo" "boa"
=> false
levenshteinAtMost 2 "foo" "boa"
=> true
levenshteinAtMost 2 "This is a sentence" "this is a sentense."
=> false
levenshteinAtMost 3 "This is a sentence" "this is a sentense."
=> true

Located at lib/strings.nix:1119 in <nixpkgs>.

Break a version string into its component parts.

splitVersion "1.2.3"
=> ["1" "2" "3"]

Located at lib/versions.nix:12 in <nixpkgs>.

Get the major version string from a string.

major "1.2.3"
=> "1"

Located at lib/versions.nix:20 in <nixpkgs>.

Get the minor version string from a string.

minor "1.2.3"
=> "2"

Located at lib/versions.nix:28 in <nixpkgs>.

Get the patch version string from a string.

patch "1.2.3"
=> "3"

Located at lib/versions.nix:36 in <nixpkgs>.

Get string of the first two parts (major and minor) of a version string.

majorMinor "1.2.3"
=> "1.2"

Located at lib/versions.nix:45 in <nixpkgs>.

Pad a version string with zeros to match the given number of components.

pad 3 "1.2"
=> "1.2.0"
pad 3 "1.3-rc1"
=> "1.3.0-rc1"
pad 3 "1.2.3.4"
=> "1.2.3"

Located at lib/versions.nix:59 in <nixpkgs>.

The identity function For when you need a function that does “nothing”.

Located at lib/trivial.nix:12 in <nixpkgs>.

The constant function

Ignores the second argument. If called with only one argument, constructs a function that always returns a static value.

let f = const 5; in f 10
=> 5

Located at lib/trivial.nix:26 in <nixpkgs>.

Pipes a value through a list of functions, left to right.

pipe 2 [
(x: x + 2)  # 2 + 2 = 4
(x: x * 2)  # 4 * 2 = 8
]
=> 8

# ideal to do text transformations
pipe [ "a/b" "a/c" ] [

# create the cp command
(map (file: ''cp "${src}/${file}" $out\n''))

# concatenate all commands into one string
lib.concatStrings

# make that string into a nix derivation
(pkgs.runCommand "copy-to-out" {})

]
=> <drv which copies all files to $out>

The output type of each function has to be the input type
of the next function, and the last function returns the
final value.

Located at lib/trivial.nix:61 in <nixpkgs>.

Concatenate two lists

concat [ 1 2 ] [ 3 4 ]
=> [ 1 2 3 4 ]

Located at lib/trivial.nix:80 in <nixpkgs>.

boolean “or”

Located at lib/trivial.nix:83 in <nixpkgs>.

boolean “and”

Located at lib/trivial.nix:86 in <nixpkgs>.

bitwise “and”

Located at lib/trivial.nix:89 in <nixpkgs>.

bitwise “or”

Located at lib/trivial.nix:94 in <nixpkgs>.

bitwise “xor”

Located at lib/trivial.nix:99 in <nixpkgs>.

bitwise “not”

Located at lib/trivial.nix:104 in <nixpkgs>.

Convert a boolean to a string.

This function uses the strings "true" and "false" to represent boolean values. Calling `toString` on a bool instead returns "1" and "" (sic!).

Located at lib/trivial.nix:114 in <nixpkgs>.

Merge two attribute sets shallowly, right side trumps left

mergeAttrs :: attrs -> attrs -> attrs

mergeAttrs { a = 1; b = 2; } { b = 3; c = 4; }
=> { a = 1; b = 3; c = 4; }

Located at lib/trivial.nix:124 in <nixpkgs>.

Flip the order of the arguments of a binary function.

flip concat [1] [2]
=> [ 2 1 ]

Located at lib/trivial.nix:138 in <nixpkgs>.

Apply function if the supplied argument is non-null.

mapNullable (x: x+1) null
=> null
mapNullable (x: x+1) 22
=> 23

Located at lib/trivial.nix:148 in <nixpkgs>.

Returns the current full nixpkgs version number.

Located at lib/trivial.nix:164 in <nixpkgs>.

Returns the current nixpkgs release number as string.

Located at lib/trivial.nix:167 in <nixpkgs>.

The latest release that is supported, at the time of release branch-off, if applicable.

Ideally, out-of-tree modules should be able to evaluate cleanly with all supported Nixpkgs versions (master, release and old release until EOL). So if possible, deprecation warnings should take effect only when all out-of-tree expressions/libs/modules can upgrade to the new way without losing support for supported Nixpkgs versions.

This release number allows deprecation warnings to be implemented such that they take effect as soon as the oldest release reaches end of life.

Located at lib/trivial.nix:180 in <nixpkgs>.

Whether a feature is supported in all supported releases (at the time of release branch-off, if applicable). See `oldestSupportedRelease`.

Located at lib/trivial.nix:186 in <nixpkgs>.

Returns the current nixpkgs release code name.

On each release the first letter is bumped and a new animal is chosen starting with that new letter.

Located at lib/trivial.nix:198 in <nixpkgs>.

Returns the current nixpkgs version suffix as string.

Located at lib/trivial.nix:201 in <nixpkgs>.

Attempts to return the the current revision of nixpkgs and returns the supplied default value otherwise.

Located at lib/trivial.nix:212 in <nixpkgs>.

Determine whether the function is being called from inside a Nix shell.

Located at lib/trivial.nix:230 in <nixpkgs>.

Determine whether the function is being called from inside pure-eval mode by seeing whether `builtins` contains `currentSystem`. If not, we must be in pure-eval mode.

Located at lib/trivial.nix:238 in <nixpkgs>.

Return minimum of two numbers.

Located at lib/trivial.nix:243 in <nixpkgs>.

Return maximum of two numbers.

Located at lib/trivial.nix:246 in <nixpkgs>.

Integer modulus

mod 11 10
=> 1
mod 1 10
=> 1

Located at lib/trivial.nix:256 in <nixpkgs>.

C-style comparisons

a < b, compare a b => -1 a == b, compare a b => 0 a > b, compare a b => 1

Located at lib/trivial.nix:267 in <nixpkgs>.

Split type into two subtypes by predicate `p`, take all elements of the first subtype to be less than all the elements of the second subtype, compare elements of a single subtype with `yes` and `no` respectively.

let cmp = splitByAndCompare (hasPrefix "foo") compare compare; in

cmp "a" "z" => -1
cmp "fooa" "fooz" => -1

cmp "f" "a" => 1
cmp "fooa" "a" => -1
# while
compare "fooa" "a" => 1

Located at lib/trivial.nix:292 in <nixpkgs>.

Reads a JSON file.

Type :: path -> any

Located at lib/trivial.nix:312 in <nixpkgs>.

Reads a TOML file.

Type :: path -> any

Located at lib/trivial.nix:319 in <nixpkgs>.

Print a warning before returning the second argument. This function behaves like `builtins.trace`, but requires a string message and formats it as a warning, including the `warning: ` prefix.

To get a call stack trace and abort evaluation, set the environment variable `NIX_ABORT_ON_WARN=true` and set the Nix options `--option pure-eval false --show-trace`

Located at lib/trivial.nix:347 in <nixpkgs>.

Like warn, but only warn when the first argument is `true`.

Located at lib/trivial.nix:357 in <nixpkgs>.

Like warnIf, but negated (warn if the first argument is `false`).

Located at lib/trivial.nix:364 in <nixpkgs>.

Like the `assert b; e` expression, but with a custom error message and without the semicolon.

If true, return the identity function, `r: r`.

If false, throw the error message.

Calls can be juxtaposed using function application, as `(r: r) a = a`, so `(r: r) (r: r) a = a`, and so forth.

throwIfNot (lib.isList overlays) "The overlays argument to nixpkgs must be a list."
lib.foldr (x: throwIfNot (lib.isFunction x) "All overlays passed to nixpkgs must be functions.") (r: r) overlays
pkgs

Located at lib/trivial.nix:386 in <nixpkgs>.

Like throwIfNot, but negated (throw if the first argument is `true`).

Located at lib/trivial.nix:393 in <nixpkgs>.

Check if the elements in a list are valid values from a enum, returning the identity function, or throwing an error message otherwise.

let colorVariants = ["bright" "dark" "black"]
in checkListOfEnum "color variants" [ "standard" "light" "dark" ] colorVariants;
=>
error: color variants: bright, black unexpected; valid ones: standard, light, dark

Located at lib/trivial.nix:405 in <nixpkgs>.

Add metadata about expected function arguments to a function. The metadata should match the format given by builtins.functionArgs, i.e. a set from expected argument to a bool representing whether that argument has a default or not. setFunctionArgs : (a → b) → Map String Bool → (a → b)

This function is necessary because you can't dynamically create a function of the { a, b ? foo, ... }: format, but some facilities like callPackage expect to be able to query expected arguments.

Located at lib/trivial.nix:428 in <nixpkgs>.

Extract the expected function arguments from a function. This works both with nix-native { a, b ? foo, ... }: style functions and functions with args set with 'setFunctionArgs'. It has the same return type and semantics as builtins.functionArgs. setFunctionArgs : (a → b) → Map String Bool.

Located at lib/trivial.nix:440 in <nixpkgs>.

Check whether something is a function or something annotated with function args.

Located at lib/trivial.nix:448 in <nixpkgs>.

Turns any non-callable values into constant functions. Returns callable values as is.

nix-repl> lib.toFunction 1 2
1

nix-repl> lib.toFunction (x: x + 1) 2
3

Located at lib/trivial.nix:463 in <nixpkgs>.

Convert the given positive integer to a string of its hexadecimal representation. For example:

toHexString 0 => "0"

toHexString 16 => "10"

toHexString 250 => "FA"

Located at lib/trivial.nix:479 in <nixpkgs>.

`toBaseDigits base i` converts the positive integer i to a list of its digits in the given base. For example:

toBaseDigits 10 123 => [ 1 2 3 ]

toBaseDigits 2 6 => [ 1 1 0 ]

toBaseDigits 16 250 => [ 15 10 ]

Located at lib/trivial.nix:505 in <nixpkgs>.

Create a list consisting of a single element. `singleton x` is sometimes more convenient with respect to indentation than `[x]` when x spans multiple lines.

singleton "foo"
=> [ "foo" ]

Located at lib/lists.nix:23 in <nixpkgs>.

Apply the function to each element in the list. Same as `map`, but arguments flipped.

forEach [ 1 2 ] (x:
toString x
)
=> [ "1" "2" ]

Located at lib/lists.nix:36 in <nixpkgs>.

“right fold” a binary function `op` between successive elements of `list` with `nul` as the starting value, i.e., `foldr op nul [x_1 x_2 ... x_n] == op x_1 (op x_2 ... (op x_n nul))`.

concat = foldr (a: b: a + b) "z"
concat [ "a" "b" "c" ]
=> "abcz"
# different types
strange = foldr (int: str: toString (int + 1) + str) "a"
strange [ 1 2 3 4 ]
=> "2345a"

Located at lib/lists.nix:53 in <nixpkgs>.

`fold` is an alias of `foldr` for historic reasons

Located at lib/lists.nix:64 in <nixpkgs>.

“left fold”, like `foldr`, but from the left: `foldl op nul [x_1 x_2 ... x_n] == op (... (op (op nul x_1) x_2) ... x_n)`.

lconcat = foldl (a: b: a + b) "z"
lconcat [ "a" "b" "c" ]
=> "zabc"
# different types
lstrange = foldl (str: int: str + toString (int + 1)) "a"
lstrange [ 1 2 3 4 ]
=> "a2345"

Located at lib/lists.nix:81 in <nixpkgs>.

Strict version of `foldl`.

The difference is that evaluation is forced upon access. Usually used with small whole results (in contrast with lazily-generated list or large lists where only a part is consumed.)

Located at lib/lists.nix:97 in <nixpkgs>.

Map with index starting from 0

imap0 (i: v: "${v}-${toString i}") ["a" "b"]
=> [ "a-0" "b-1" ]

Located at lib/lists.nix:107 in <nixpkgs>.

Map with index starting from 1

imap1 (i: v: "${v}-${toString i}") ["a" "b"]
=> [ "a-1" "b-2" ]

Located at lib/lists.nix:117 in <nixpkgs>.

Map and concatenate the result.

concatMap (x: [x] ++ ["z"]) ["a" "b"]
=> [ "a" "z" "b" "z" ]

Located at lib/lists.nix:127 in <nixpkgs>.

Flatten the argument into a single list; that is, nested lists are spliced into the top-level lists.

flatten [1 [2 [3] 4] 5]
=> [1 2 3 4 5]
flatten 1
=> [1]

Located at lib/lists.nix:138 in <nixpkgs>.

Remove elements equal to 'e' from a list. Useful for buildInputs.

remove 3 [ 1 3 4 3 ]
=> [ 1 4 ]

Located at lib/lists.nix:151 in <nixpkgs>.

Find the sole element in the list matching the specified predicate, returns `default` if no such element exists, or `multiple` if there are multiple matching elements.

findSingle (x: x == 3) "none" "multiple" [ 1 3 3 ]
=> "multiple"
findSingle (x: x == 3) "none" "multiple" [ 1 3 ]
=> 3
findSingle (x: x == 3) "none" "multiple" [ 1 9 ]
=> "none"

Located at lib/lists.nix:169 in <nixpkgs>.

Find the first element in the list matching the specified predicate or return `default` if no such element exists.

findFirst (x: x > 3) 7 [ 1 6 4 ]
=> 6
findFirst (x: x > 9) 7 [ 1 6 4 ]
=> 7

Located at lib/lists.nix:194 in <nixpkgs>.

Return true if function `pred` returns true for at least one element of `list`.

any isString [ 1 "a" { } ]
=> true
any isString [ 1 { } ]
=> false

Located at lib/lists.nix:215 in <nixpkgs>.

Return true if function `pred` returns true for all elements of `list`.

all (x: x < 3) [ 1 2 ]
=> true
all (x: x < 3) [ 1 2 3 ]
=> false

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

Count how many elements of `list` match the supplied predicate function.

count (x: x == 3) [ 3 2 3 4 6 ]
=> 2

Located at lib/lists.nix:239 in <nixpkgs>.

Return a singleton list or an empty list, depending on a boolean value. Useful when building lists with optional elements (e.g. `++ optional (system == "i686-linux") firefox`).

optional true "foo"
=> [ "foo" ]
optional false "foo"
=> [ ]

Located at lib/lists.nix:255 in <nixpkgs>.

Return a list or an empty list, depending on a boolean value.

optionals true [ 2 3 ]
=> [ 2 3 ]
optionals false [ 2 3 ]
=> [ ]

Located at lib/lists.nix:267 in <nixpkgs>.

If argument is a list, return it; else, wrap it in a singleton list. If you're using this, you should almost certainly reconsider if there isn't a more "well-typed" approach.

toList [ 1 2 ]
=> [ 1 2 ]
toList "hi"
=> [ "hi "]

Located at lib/lists.nix:284 in <nixpkgs>.

Return a list of integers from `first` up to and including `last`.

range 2 4
=> [ 2 3 4 ]
range 3 2
=> [ ]

Located at lib/lists.nix:296 in <nixpkgs>.

Return a list with `n` copies of an element.

replicate 3 "a"
=> [ "a" "a" "a" ]
replicate 2 true
=> [ true true ]

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

Splits the elements of a list in two lists, `right` and `wrong`, depending on the evaluation of a predicate.

partition (x: x > 2) [ 5 1 2 3 4 ]
=> { right = [ 5 3 4 ]; wrong = [ 1 2 ]; }

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

Splits the elements of a list into many lists, using the return value of a predicate. Predicate should return a string which becomes keys of attrset `groupBy` returns.

`groupBy'` allows to customise the combining function and initial value

groupBy (x: boolToString (x > 2)) [ 5 1 2 3 4 ]
=> { true = [ 5 3 4 ]; false = [ 1 2 ]; }
groupBy (x: x.name) [ {name = "icewm"; script = "icewm &";}
{name = "xfce";  script = "xfce4-session &";}
{name = "icewm"; script = "icewmbg &";}
{name = "mate";  script = "gnome-session &";}
]
=> { icewm = [ { name = "icewm"; script = "icewm &"; }
{ name = "icewm"; script = "icewmbg &"; } ];
mate  = [ { name = "mate";  script = "gnome-session &"; } ];
xfce  = [ { name = "xfce";  script = "xfce4-session &"; } ];
}

groupBy' builtins.add 0 (x: boolToString (x > 2)) [ 5 1 2 3 4 ]
=> { true = 12; false = 3; }

Located at lib/lists.nix:356 in <nixpkgs>.

Merges two lists of the same size together. If the sizes aren't the same the merging stops at the shortest. How both lists are merged is defined by the first argument.

zipListsWith (a: b: a + b) ["h" "l"] ["e" "o"]
=> ["he" "lo"]

Located at lib/lists.nix:376 in <nixpkgs>.

Merges two lists of the same size together. If the sizes aren't the same the merging stops at the shortest.

zipLists [ 1 2 ] [ "a" "b" ]
=> [ { fst = 1; snd = "a"; } { fst = 2; snd = "b"; } ]

Located at lib/lists.nix:395 in <nixpkgs>.

Reverse the order of the elements of a list.

reverseList [ "b" "o" "j" ]
=> [ "j" "o" "b" ]

Located at lib/lists.nix:406 in <nixpkgs>.

Depth-First Search (DFS) for lists `list != []`.

`before a b == true` means that `b` depends on `a` (there's an edge from `b` to `a`).

listDfs true hasPrefix [ "/home/user" "other" "/" "/home" ]
== { minimal = "/";                  # minimal element
visited = [ "/home/user" ];     # seen elements (in reverse order)
rest    = [ "/home" "other" ];  # everything else
}

listDfs true hasPrefix [ "/home/user" "other" "/" "/home" "/" ]
== { cycle   = "/";                  # cycle encountered at this element
loops   = [ "/" ];              # and continues to these elements
visited = [ "/" "/home/user" ]; # elements leading to the cycle (in reverse order)
rest    = [ "/home" "other" ];  # everything else

Located at lib/lists.nix:428 in <nixpkgs>.

Sort a list based on a partial ordering using DFS. This implementation is O(N^2), if your ordering is linear, use `sort` instead.

`before a b == true` means that `b` should be after `a` in the result.

toposort hasPrefix [ "/home/user" "other" "/" "/home" ]
== { result = [ "/" "/home" "/home/user" "other" ]; }

toposort hasPrefix [ "/home/user" "other" "/" "/home" "/" ]
== { cycle = [ "/home/user" "/" "/" ]; # path leading to a cycle
loops = [ "/" ]; }                # loops back to these elements

toposort hasPrefix [ "other" "/home/user" "/home" "/" ]
== { result = [ "other" "/" "/home" "/home/user" ]; }

toposort (a: b: a < b) [ 3 2 1 ] == { result = [ 1 2 3 ]; }

Located at lib/lists.nix:467 in <nixpkgs>.

Sort a list based on a comparator function which compares two elements and returns true if the first argument is strictly below the second argument. The returned list is sorted in an increasing order. The implementation does a quick-sort.

sort (a: b: a < b) [ 5 3 7 ]
=> [ 3 5 7 ]

Located at lib/lists.nix:495 in <nixpkgs>.

Compare two lists element-by-element.

compareLists compare [] []
=> 0
compareLists compare [] [ "a" ]
=> -1
compareLists compare [ "a" ] []
=> 1
compareLists compare [ "a" "b" ] [ "a" "c" ]
=> -1

Located at lib/lists.nix:524 in <nixpkgs>.

Sort list using "Natural sorting". Numeric portions of strings are sorted in numeric order.

naturalSort ["disk11" "disk8" "disk100" "disk9"]
=> ["disk8" "disk9" "disk11" "disk100"]
naturalSort ["10.46.133.149" "10.5.16.62" "10.54.16.25"]
=> ["10.5.16.62" "10.46.133.149" "10.54.16.25"]
naturalSort ["v0.2" "v0.15" "v0.0.9"]
=> [ "v0.0.9" "v0.2" "v0.15" ]

Located at lib/lists.nix:547 in <nixpkgs>.

Return the first (at most) N elements of a list.

take 2 [ "a" "b" "c" "d" ]
=> [ "a" "b" ]
take 2 [ ]
=> [ ]

Located at lib/lists.nix:565 in <nixpkgs>.

Remove the first (at most) N elements of a list.

drop 2 [ "a" "b" "c" "d" ]
=> [ "c" "d" ]
drop 2 [ ]
=> [ ]

Located at lib/lists.nix:579 in <nixpkgs>.

Return a list consisting of at most `count` elements of `list`, starting at index `start`.

sublist 1 3 [ "a" "b" "c" "d" "e" ]
=> [ "b" "c" "d" ]
sublist 1 3 [ ]
=> [ ]

Located at lib/lists.nix:596 in <nixpkgs>.

Return the last element of a list.

This function throws an error if the list is empty.

last [ 1 2 3 ]
=> 3

Located at lib/lists.nix:620 in <nixpkgs>.

Return all elements but the last.

This function throws an error if the list is empty.

init [ 1 2 3 ]
=> [ 1 2 ]

Located at lib/lists.nix:634 in <nixpkgs>.

Return the image of the cross product of some lists by a function.

crossLists (x:y: "${toString x}${toString y}") [[1 2] [3 4]]
=> [ "13" "14" "23" "24" ]

Located at lib/lists.nix:645 in <nixpkgs>.

Remove duplicate elements from the list. O(n^2) complexity.

unique [ 3 2 3 4 ]
=> [ 3 2 4 ]

Located at lib/lists.nix:658 in <nixpkgs>.

Intersects list 'e' and another list. O(nm) complexity.

intersectLists [ 1 2 3 ] [ 6 3 2 ]
=> [ 3 2 ]

Located at lib/lists.nix:666 in <nixpkgs>.

Subtracts list 'e' from another list. O(nm) complexity.

subtractLists [ 3 2 ] [ 1 2 3 4 5 3 ]
=> [ 1 4 5 ]

Located at lib/lists.nix:674 in <nixpkgs>.

Test if two lists have no common element. It should be slightly more efficient than (intersectLists a b == [])

Located at lib/lists.nix:679 in <nixpkgs>.

Conditionally trace the supplied message, based on a predicate.

traceIf true "hello" 3
trace: hello
=> 3

Located at lib/debug.nix:51 in <nixpkgs>.

Trace the supplied value after applying a function to it, and return the original value.

traceValFn (v: "mystring ${v}") "foo"
trace: mystring foo
=> "foo"

Located at lib/debug.nix:69 in <nixpkgs>.

Trace the supplied value and return it.

traceVal 42
# trace: 42
=> 42

Located at lib/debug.nix:84 in <nixpkgs>.

`builtins.trace`, but the value is `builtins.deepSeq`ed first.

trace { a.b.c = 3; } null
trace: { a = <CODE>; }
=> null
traceSeq { a.b.c = 3; } null
trace: { a = { b = { c = 3; }; }; }
=> null

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

Like `traceSeq`, but only evaluate down to depth n. This is very useful because lots of `traceSeq` usages lead to an infinite recursion.

traceSeqN 2 { a.b.c = 3; } null
trace: { a = { b = {…}; }; }
=> null

Located at lib/debug.nix:115 in <nixpkgs>.

A combination of `traceVal` and `traceSeq` that applies a provided function to the value to be traced after `deepSeq`ing it.

Located at lib/debug.nix:132 in <nixpkgs>.

A combination of `traceVal` and `traceSeq`.

Located at lib/debug.nix:139 in <nixpkgs>.

A combination of `traceVal` and `traceSeqN` that applies a provided function to the value to be traced.

Located at lib/debug.nix:143 in <nixpkgs>.

A combination of `traceVal` and `traceSeqN`.

Located at lib/debug.nix:151 in <nixpkgs>.

Trace the input and output of a function `f` named `name`, both down to `depth`.

This is useful for adding around a function call, to see the before/after of values as they are transformed.

traceFnSeqN 2 "id" (x: x) { a.b.c = 3; }
trace: { fn = "id"; from = { a.b = {…}; }; to = { a.b = {…}; }; }
=> { a.b.c = 3; }

Located at lib/debug.nix:164 in <nixpkgs>.

Evaluates a set of tests.

A test is an attribute set `{expr, expected}`, denoting an expression and its expected result.

The result is a `list` of __failed tests__, each represented as `{name, expected, result}`,

- expected - What was passed as `expected` - result - The actual `result` of the test

Used for regression testing of the functions in lib; see tests.nix for more examples.

Important: Only attributes that start with `test` are executed.

- If you want to run only a subset of the tests add the attribute `tests = ["testName"];`

runTests {
testAndOk = {
expr = lib.and true false;
expected = false;
};
testAndFail = {
expr = lib.and true false;
expected = true;
};
}
->
[
{
name = "testAndFail";
expected = true;
result = false;
}
]

Located at lib/debug.nix:236 in <nixpkgs>.

Create a test assuming that list elements are `true`.

{ testX = allTrue [ true ]; }

Located at lib/debug.nix:252 in <nixpkgs>.

Returns true when the given argument is an option

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

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

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

All keys default to `null` when not given.

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

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

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

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

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

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

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:152 in <nixpkgs>.

Like mkPackageOption, but emit an mdDoc description instead of DocBook.

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

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.

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

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

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

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

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

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

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

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

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

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.

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

Ensures that the given option value (default or example) is a `_type`d string by rendering Nix values to `literalExpression`s.

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

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.

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

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

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

Transition marker for documentation that's already migrated to markdown syntax.

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

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.

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

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