nix-super/doc/manual/src/language/constructs.md

355 lines
9.1 KiB
Markdown
Raw Normal View History

2020-07-23 00:17:48 +03:00
# Language Constructs
## Recursive sets
2020-07-23 00:17:48 +03:00
Recursive sets are just normal sets, but the attributes can refer to
each other. For example,
2020-07-31 16:43:25 +03:00
```nix
rec {
x = y;
y = 123;
}.x
```
2020-07-23 00:17:48 +03:00
evaluates to `123`. Note that without `rec` the binding `x = y;` would
refer to the variable `y` in the surrounding scope, if one exists, and
would be invalid if no such variable exists. That is, in a normal
(non-recursive) set, attributes are not added to the lexical scope; in a
recursive set, they are.
Recursive sets of course introduce the danger of infinite recursion. For
example, the expression
2020-07-23 00:17:48 +03:00
2020-07-31 16:43:25 +03:00
```nix
rec {
x = y;
y = x;
}.x
```
2020-07-23 00:17:48 +03:00
will crash with an `infinite recursion encountered` error message.
2020-07-23 00:17:48 +03:00
## Let-expressions
2020-07-23 00:17:48 +03:00
A let-expression allows you to define local variables for an expression.
For instance,
2020-07-31 16:43:25 +03:00
```nix
let
x = "foo";
y = "bar";
in x + y
```
2020-07-23 00:17:48 +03:00
evaluates to `"foobar"`.
## Inheriting attributes
2020-07-23 00:17:48 +03:00
When defining a set or in a let-expression it is often convenient to
copy variables from the surrounding lexical scope (e.g., when you want
to propagate attributes). This can be shortened using the `inherit`
keyword. For instance,
2020-07-31 16:43:25 +03:00
```nix
let x = 123; in
{ inherit x;
y = 456;
}
```
2020-07-23 00:17:48 +03:00
is equivalent to
2020-07-31 16:43:25 +03:00
```nix
let x = 123; in
{ x = x;
y = 456;
}
```
2020-07-23 00:17:48 +03:00
and both evaluate to `{ x = 123; y = 456; }`. (Note that this works
because `x` is added to the lexical scope by the `let` construct.) It is
also possible to inherit attributes from another set. For instance, in
this fragment from `all-packages.nix`,
2020-07-31 16:43:25 +03:00
```nix
graphviz = (import ../tools/graphics/graphviz) {
inherit fetchurl stdenv libpng libjpeg expat x11 yacc;
inherit (xlibs) libXaw;
};
2020-07-23 00:17:48 +03:00
2020-07-31 16:43:25 +03:00
xlibs = {
libX11 = ...;
libXaw = ...;
2020-07-23 00:17:48 +03:00
...
2020-07-31 16:43:25 +03:00
}
libpng = ...;
libjpg = ...;
...
2020-07-23 00:17:48 +03:00
```
the set used in the function call to the function defined in
`../tools/graphics/graphviz` inherits a number of variables from the
surrounding scope (`fetchurl` ... `yacc`), but also inherits `libXaw`
(the X Athena Widgets) from the `xlibs` (X11 client-side libraries) set.
Summarizing the fragment
2020-07-31 16:43:25 +03:00
```nix
...
inherit x y z;
inherit (src-set) a b c;
...
```
2020-07-23 00:17:48 +03:00
is equivalent to
2020-07-31 16:43:25 +03:00
```nix
...
x = x; y = y; z = z;
a = src-set.a; b = src-set.b; c = src-set.c;
...
```
2020-07-23 00:17:48 +03:00
when used while defining local variables in a let-expression or while
defining a set.
## Functions
2020-07-23 00:17:48 +03:00
Functions have the following form:
2020-07-31 16:43:25 +03:00
```nix
pattern: body
```
2020-07-23 00:17:48 +03:00
The pattern specifies what the argument of the function must look like,
and binds variables in the body to (parts of) the argument. There are
three kinds of patterns:
- If a pattern is a single identifier, then the function matches any
argument. Example:
2020-07-31 16:43:25 +03:00
```nix
let negate = x: !x;
concat = x: y: x + y;
in if negate true then concat "foo" "bar" else ""
```
2020-07-23 00:17:48 +03:00
Note that `concat` is a function that takes one argument and returns
a function that takes another argument. This allows partial
parameterisation (i.e., only filling some of the arguments of a
function); e.g.,
2020-07-31 16:43:25 +03:00
```nix
map (concat "foo") [ "bar" "bla" "abc" ]
```
2020-07-23 00:17:48 +03:00
2020-07-31 16:43:25 +03:00
evaluates to `[ "foobar" "foobla" "fooabc" ]`.
2020-07-23 00:17:48 +03:00
- A *set pattern* of the form `{ name1, name2, …, nameN }` matches a
set containing the listed attributes, and binds the values of those
attributes to variables in the function body. For example, the
function
2020-07-31 16:43:25 +03:00
```nix
{ x, y, z }: z + y + x
```
2020-07-23 00:17:48 +03:00
can only be called with a set containing exactly the attributes `x`,
`y` and `z`. No other attributes are allowed. If you want to allow
additional arguments, you can use an ellipsis (`...`):
2020-07-31 16:43:25 +03:00
```nix
{ x, y, z, ... }: z + y + x
```
2020-07-23 00:17:48 +03:00
This works on any set that contains at least the three named
attributes.
2020-07-31 16:43:25 +03:00
It is possible to provide *default values* for attributes, in
which case they are allowed to be missing. A default value is
specified by writing `name ? e`, where *e* is an arbitrary
expression. For example,
2020-07-23 00:17:48 +03:00
2020-07-31 16:43:25 +03:00
```nix
{ x, y ? "foo", z ? "bar" }: z + y + x
```
2020-07-23 00:17:48 +03:00
specifies a function that only requires an attribute named `x`, but
optionally accepts `y` and `z`.
- An `@`-pattern provides a means of referring to the whole value
being matched:
2020-07-31 16:43:25 +03:00
```nix
args@{ x, y, z, ... }: z + y + x + args.a
2020-07-23 00:17:48 +03:00
```
but can also be written as:
2020-07-31 16:43:25 +03:00
```nix
{ x, y, z, ... } @ args: z + y + x + args.a
2020-07-23 00:17:48 +03:00
```
Here `args` is bound to the entire argument, which is further
matched against the pattern `{ x, y, z,
... }`. `@`-pattern makes mainly sense with an ellipsis(`...`) as
you can access attribute names as `a`, using `args.a`, which was
given as an additional attribute to the function.
> **Warning**
>
> The `args@` expression is bound to the argument passed to the
> function which means that attributes with defaults that aren't
> explicitly specified in the function call won't cause an
> evaluation error, but won't exist in `args`.
>
> For instance
>
2020-07-31 16:43:25 +03:00
> ```nix
> let
> function = args@{ a ? 23, ... }: args;
> in
> function {}
> ````
2020-07-23 00:17:48 +03:00
>
> will evaluate to an empty attribute set.
Note that functions do not have names. If you want to give them a name,
you can bind them to an attribute, e.g.,
2020-07-31 16:43:25 +03:00
```nix
let concat = { x, y }: x + y;
in concat { x = "foo"; y = "bar"; }
```
2020-07-23 00:17:48 +03:00
## Conditionals
2020-07-23 00:17:48 +03:00
Conditionals look like this:
2020-07-31 16:43:25 +03:00
```nix
if e1 then e2 else e3
```
2020-07-23 00:17:48 +03:00
where *e1* is an expression that should evaluate to a Boolean value
2020-07-23 00:17:48 +03:00
(`true` or `false`).
## Assertions
2020-07-23 00:17:48 +03:00
Assertions are generally used to check that certain requirements on or
between features and dependencies hold. They look like this:
2020-07-31 16:43:25 +03:00
```nix
assert e1; e2
```
2020-07-23 00:17:48 +03:00
where *e1* is an expression that should evaluate to a Boolean value. If
it evaluates to `true`, *e2* is returned; otherwise expression
evaluation is aborted and a backtrace is printed.
2020-07-23 00:17:48 +03:00
Here is a Nix expression for the Subversion package that shows how
assertions can be used:.
2020-07-31 16:43:25 +03:00
```nix
{ localServer ? false
, httpServer ? false
, sslSupport ? false
, pythonBindings ? false
, javaSwigBindings ? false
, javahlBindings ? false
, stdenv, fetchurl
, openssl ? null, httpd ? null, db4 ? null, expat, swig ? null, j2sdk ? null
}:
assert localServer -> db4 != null; ①
assert httpServer -> httpd != null && httpd.expat == expat; ②
assert sslSupport -> openssl != null && (httpServer -> httpd.openssl == openssl); ③
assert pythonBindings -> swig != null && swig.pythonSupport;
assert javaSwigBindings -> swig != null && swig.javaSupport;
assert javahlBindings -> j2sdk != null;
stdenv.mkDerivation {
name = "subversion-1.1.1";
...
openssl = if sslSupport then openssl else null; ④
...
}
```
2020-07-23 00:17:48 +03:00
The points of interest are:
2020-07-23 00:17:48 +03:00
1. This assertion states that if Subversion is to have support for
2020-07-23 00:17:48 +03:00
local repositories, then Berkeley DB is needed. So if the Subversion
function is called with the `localServer` argument set to `true` but
the `db4` argument set to `null`, then the evaluation fails.
2022-01-13 15:33:09 +02:00
Note that `->` is the [logical
implication](https://en.wikipedia.org/wiki/Truth_table#Logical_implication)
Boolean operation.
2. This is a more subtle condition: if Subversion is built with Apache
2020-07-23 00:17:48 +03:00
(`httpServer`) support, then the Expat library (an XML library) used
by Subversion should be same as the one used by Apache. This is
because in this configuration Subversion code ends up being linked
with Apache code, and if the Expat libraries do not match, a build-
or runtime link error or incompatibility might occur.
3. This assertion says that in order for Subversion to have SSL support
2020-07-23 00:17:48 +03:00
(so that it can access `https` URLs), an OpenSSL library must be
passed. Additionally, it says that *if* Apache support is enabled,
then Apache's OpenSSL should match Subversion's. (Note that if
Apache support is not enabled, we don't care about Apache's
OpenSSL.)
4. The conditional here is not really related to assertions, but is
2020-07-23 00:17:48 +03:00
worth pointing out: it ensures that if SSL support is disabled, then
the Subversion derivation is not dependent on OpenSSL, even if a
non-`null` value was passed. This prevents an unnecessary rebuild of
Subversion if OpenSSL changes.
## With-expressions
2020-07-23 00:17:48 +03:00
A *with-expression*,
2020-07-31 16:43:25 +03:00
```nix
with e1; e2
```
2020-07-23 00:17:48 +03:00
introduces the set *e1* into the lexical scope of the expression *e2*.
For instance,
2020-07-23 00:17:48 +03:00
2020-07-31 16:43:25 +03:00
```nix
let as = { x = "foo"; y = "bar"; };
in with as; x + y
```
2020-07-23 00:17:48 +03:00
evaluates to `"foobar"` since the `with` adds the `x` and `y` attributes
of `as` to the lexical scope in the expression `x + y`. The most common
use of `with` is in conjunction with the `import` function. E.g.,
2020-07-31 16:43:25 +03:00
```nix
with (import ./definitions.nix); ...
```
2020-07-23 00:17:48 +03:00
makes all attributes defined in the file `definitions.nix` available as
if they were defined locally in a `let`-expression.
The bindings introduced by `with` do not shadow bindings introduced by
other means, e.g.
2020-07-31 16:43:25 +03:00
```nix
let a = 3; in with { a = 1; }; let a = 4; in with { a = 2; }; ...
```
2020-07-23 00:17:48 +03:00
establishes the same scope as
2020-07-31 16:43:25 +03:00
```nix
let a = 1; in let a = 2; in let a = 3; in let a = 4; in ...
```
2020-07-23 00:17:48 +03:00
## Comments
2020-07-23 00:17:48 +03:00
Comments can be single-line, started with a `#` character, or
2020-07-31 16:43:25 +03:00
inline/multi-line, enclosed within `/* ... */`.