# Nix Language The Nix language is designed for conveniently creating and composing *derivations* – precise descriptions of how contents of existing files are used to derive new files. It is: - *domain-specific* It comes with [built-in functions](@docroot@/language/builtins.md) to integrate with the Nix store, which manages files and performs the derivations declared in the Nix language. - *declarative* There is no notion of executing sequential steps. Dependencies between operations are established only through data. - *pure* Values cannot change during computation. Functions always produce the same output if their input does not change. - *functional* Functions are like any other value. Functions can be assigned to names, taken as arguments, or returned by functions. - *lazy* Values are only computed when they are needed. - *dynamically typed* Type errors are only detected when expressions are evaluated. # Overview This is an incomplete overview of language features, by example.
Example Description
*Basic values*
`"hello world"` A string
``` '' multi line string '' ``` A multi-line string. Strips common prefixed whitespace. Evaluates to `"multi\n line\n  string"`.
`"hello ${ { a = "world"; }.a }"` `"1 2 ${toString 3}"` `"${pkgs.bash}/bin/sh"` String interpolation (expands to `"hello world"`, `"1 2 3"`, `"/nix/store/-bash-/bin/sh"`)
`true`, `false` Booleans
`null` Null value
`123` An integer
`3.141` A floating point number
`/etc` An absolute path
`./foo.png` A path relative to the file containing this Nix expression
`~/.config` A home path. Evaluates to the `"/.config"`.
`` Search path for Nix files. Value determined by [`$NIX_PATH` environment variable](../command-ref/env-common.md#env-NIX_PATH).
*Compound values*
`{ x = 1; y = 2; }` A set with attributes named `x` and `y`
`{ foo.bar = 1; }` A nested set, equivalent to `{ foo = { bar = 1; }; }`
`rec { x = "foo"; y = x + "bar"; }` A recursive set, equivalent to `{ x = "foo"; y = "foobar"; }`
`[ "foo" "bar" "baz" ]` `[ 1 2 3 ]` `[ (f 1) { a = 1; b = 2; } [ "c" ] ]` Lists with three elements.
*Operators*
`"foo" + "bar"` String concatenation
`1 + 2` Integer addition
`"foo" == "f" + "oo"` Equality test (evaluates to `true`)
`"foo" != "bar"` Inequality test (evaluates to `true`)
`!true` Boolean negation
`{ x = 1; y = 2; }.x` Attribute selection (evaluates to `1`)
`{ x = 1; y = 2; }.z or 3` Attribute selection with default (evaluates to `3`)
`{ x = 1; y = 2; } // { z = 3; }` Merge two sets (attributes in the right-hand set taking precedence)
*Control structures*
`if 1 + 1 == 2 then "yes!" else "no!"` Conditional expression
`assert 1 + 1 == 2; "yes!"` Assertion check (evaluates to `"yes!"`).
`let x = "foo"; y = "bar"; in x + y` Variable definition
`with builtins; head [ 1 2 3 ]` Add all attributes from the given set to the scope (evaluates to `1`)
*Functions (lambdas)*
`x: x + 1` A function that expects an integer and returns it increased by 1
`x: y: x + y` Curried function, equivalent to `x: (y: x + y)`. Can be used like a function that takes two arguments and returns their sum.
`(x: x + 1) 100` A function call (evaluates to 101)
`let inc = x: x + 1; in inc (inc (inc 100))` A function bound to a variable and subsequently called by name (evaluates to 103)
`{ x, y }: x + y` A function that expects a set with required attributes `x` and `y` and concatenates them
`{ x, y ? "bar" }: x + y` A function that expects a set with required attribute `x` and optional `y`, using `"bar"` as default value for `y`
`{ x, y, ... }: x + y` A function that expects a set with required attributes `x` and `y` and ignores any other attributes
`{ x, y } @ args: x + y` `args @ { x, y }: x + y` A function that expects a set with required attributes `x` and `y`, and binds the whole set to `args`
*Built-in functions*
`import ./foo.nix` Load and return Nix expression in given file
`map (x: x + x) [ 1 2 3 ]` Apply a function to every element of a list (evaluates to `[ 2 4 6 ]`)