# Nix Language The Nix language is a pure, lazy, functional language. Purity means that operations in the language don't have side-effects (for instance, there is no variable assignment). Laziness means that arguments to functions are evaluated only when they are needed. Functional means that functions are “normal” values that can be passed around and manipulated in interesting ways. The language is not a full-featured, general purpose language. Its main job is to describe packages, compositions of packages, and the variability within packages. This section presents the various features of the language. # 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 ${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. 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 pkgs.lib; 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 ]`)