commit 800c1f15a3ad3cbbce948d652b46406adeb2fc56 · pyrox.dev/nixpkgs

nixos/doc/manual/configuration/config-syntax.xml

···

       21
       21
        
        <xi:include href="../from_md/configuration/config-file.section.xml" />

     

       22
       22
        
        <xi:include href="../from_md/configuration/abstractions.section.xml" />

     

       23
       23
        
        <xi:include href="../from_md/configuration/modularity.section.xml" />

     

       24
       24
       +
        <xi:include href="../from_md/configuration/summary.section.xml" />

     

       24
       25
        
       </chapter>

+46

nixos/doc/manual/configuration/summary.section.md

···

       1
       1
       +
       # Syntax Summary {#sec-nix-syntax-summary}

     

       2
       2
       +
       

     

       3
       3
       +
       Below is a summary of the most important syntactic constructs in the Nix

     

       4
       4
       +
       expression language. It's not complete. In particular, there are many

     

       5
       5
       +
       other built-in functions. See the [Nix

     

       6
       6
       +
       manual](https://nixos.org/nix/manual/#chap-writing-nix-expressions) for

     

       7
       7
       +
       the rest.

     

       8
       8
       +
       

     

       9
       9
       +
       | Example                                       | Description                                                                                                        |

     

       10
       10
       +
       |-----------------------------------------------|--------------------------------------------------------------------------------------------------------------------|

     

       11
       11
       +
       | *Basic values*                                |                                                                                                                    |

     

       12
       12
       +
       | `"Hello world"`                               | A string                                                                                                           |

     

       13
       13
       +
       | `"${pkgs.bash}/bin/sh"`                       | A string containing an expression (expands to `"/nix/store/hash-bash-version/bin/sh"`)                             |

     

       14
       14
       +
       | `true`, `false`                               | Booleans                                                                                                           |

     

       15
       15
       +
       | `123`                                         | An integer                                                                                                         |

     

       16
       16
       +
       | `./foo.png`                                   | A path (relative to the containing Nix expression)                                                                 |

     

       17
       17
       +
       | *Compound values*                             |                                                                                                                    |

     

       18
       18
       +
       | `{ x = 1; y = 2; }`                           | A set with attributes named `x` and `y`                                                                            |

     

       19
       19
       +
       | `{ foo.bar = 1; }`                            | A nested set, equivalent to `{ foo = { bar = 1; }; }`                                                              |

     

       20
       20
       +
       | `rec { x = "foo"; y = x + "bar"; }`           | A recursive set, equivalent to `{ x = "foo"; y = "foobar"; }`                                                      |

     

       21
       21
       +
       | `[ "foo" "bar" ]`                             | A list with two elements                                                                                           |

     

       22
       22
       +
       | *Operators*                                   |                                                                                                                    |

     

       23
       23
       +
       | `"foo" + "bar"`                               | String concatenation                                                                                               |

     

       24
       24
       +
       | `1 + 2`                                       | Integer addition                                                                                                   |

     

       25
       25
       +
       | `"foo" == "f" + "oo"`                         | Equality test (evaluates to `true`)                                                                                |

     

       26
       26
       +
       | `"foo" != "bar"`                              | Inequality test (evaluates to `true`)                                                                              |

     

       27
       27
       +
       | `!true`                                       | Boolean negation                                                                                                   |

     

       28
       28
       +
       | `{ x = 1; y = 2; }.x`                         | Attribute selection (evaluates to `1`)                                                                             |

     

       29
       29
       +
       | `{ x = 1; y = 2; }.z or 3`                    | Attribute selection with default (evaluates to `3`)                                                                |

     

       30
       30
       +
       | `{ x = 1; y = 2; } // { z = 3; }`             | Merge two sets (attributes in the right-hand set taking precedence)                                                |

     

       31
       31
       +
       | *Control structures*                          |                                                                                                                    |

     

       32
       32
       +
       | `if 1 + 1 == 2 then "yes!" else "no!"`        | Conditional expression                                                                                             |

     

       33
       33
       +
       | `assert 1 + 1 == 2; "yes!"`                   | Assertion check (evaluates to `"yes!"`). See [](#sec-assertions) for using assertions in modules                   |

     

       34
       34
       +
       | `let x = "foo"; y = "bar"; in x + y`          | Variable definition                                                                                                |

     

       35
       35
       +
       | `with pkgs.lib; head [ 1 2 3 ]`               | Add all attributes from the given set to the scope (evaluates to `1`)                                              |

     

       36
       36
       +
       | *Functions (lambdas)*                         |                                                                                                                    |

     

       37
       37
       +
       | `x: x + 1`                                    | A function that expects an integer and returns it increased by 1                                                   |

     

       38
       38
       +
       | `(x: x + 1) 100`                              | A function call (evaluates to 101)                                                                                 |

     

       39
       39
       +
       | `let inc = x: x + 1; in inc (inc (inc 100))`  | A function bound to a variable and subsequently called by name (evaluates to 103)                                  |

     

       40
       40
       +
       | `{ x, y }: x + y`                             | A function that expects a set with required attributes `x` and `y` and concatenates them                           |

     

       41
       41
       +
       | `{ 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` |

     

       42
       42
       +
       | `{ x, y, ... }: x + y`                        | A function that expects a set with required attributes `x` and `y` and ignores any other attributes                |

     

       43
       43
       +
       | `{ x, y } @ args: x + y`                      | A function that expects a set with required attributes `x` and `y`, and binds the whole set to `args`              |

     

       44
       44
       +
       | *Built-in functions*                          |                                                                                                                    |

     

       45
       45
       +
       | `import ./foo.nix`                            | Load and return Nix expression in given file                                                                       |

     

       46
       46
       +
       | `map (x: x + x) [ 1 2 3 ]`                    | Apply a function to every element of a list (evaluates to `[ 2 4 6 ]`)                                             |

-227

nixos/doc/manual/configuration/summary.xml

···

       1
       1
       -
       <section xmlns="http://docbook.org/ns/docbook"

     

       2
       2
       -
           xmlns:xlink="http://www.w3.org/1999/xlink"

     

       3
       3
       -
           xmlns:xi="http://www.w3.org/2001/XInclude"

     

       4
       4
       -
           version="5.0"

     

       5
       5
       -
           xml:id="sec-nix-syntax-summary">

     

       6
       6
       -
        <title>Syntax Summary</title>

     

       7
       7
       -
       

     

       8
       8
       -
        <para>

     

       9
       9
       -
         Below is a summary of the most important syntactic constructs in the Nix

     

       10
       10
       -
         expression language. It’s not complete. In particular, there are many other

     

       11
       11
       -
         built-in functions. See the

     

       12
       12
       -
         <link

     

       13
       13
       -
       xlink:href="https://nixos.org/nix/manual/#chap-writing-nix-expressions">Nix

     

       14
       14
       -
         manual</link> for the rest.

     

       15
       15
       -
        </para>

     

       16
       16
       -
       

     

       17
       17
       -
        <informaltable frame='none'>

     

       18
       18
       -
         <tgroup cols='2'>

     

       19
       19
       -
          <colspec colname='c1' rowsep='1' colsep='1' />

     

       20
       20
       -
          <colspec colname='c2' rowsep='1' />

     

       21
       21
       -
          <thead>

     

       22
       22
       -
           <row>

     

       23
       23
       -
            <entry>Example</entry>

     

       24
       24
       -
            <entry>Description</entry>

     

       25
       25
       -
           </row>

     

       26
       26
       -
          </thead>

     

       27
       27
       -
          <tbody>

     

       28
       28
       -
           <row>

     

       29
       29
       -
            <entry namest="c1" nameend="c2"><emphasis>Basic values</emphasis>

     

       30
       30
       -
            </entry>

     

       31
       31
       -
           </row>

     

       32
       32
       -
           <row>

     

       33
       33
       -
            <entry><literal>"Hello world"</literal>

     

       34
       34
       -
            </entry>

     

       35
       35
       -
            <entry>A string</entry>

     

       36
       36
       -
           </row>

     

       37
       37
       -
           <row>

     

       38
       38
       -
            <entry><literal>"${pkgs.bash}/bin/sh"</literal>

     

       39
       39
       -
            </entry>

     

       40
       40
       -
            <entry>A string containing an expression (expands to <literal>"/nix/store/<replaceable>hash</replaceable>-bash-<replaceable>version</replaceable>/bin/sh"</literal>)</entry>

     

       41
       41
       -
           </row>

     

       42
       42
       -
           <row>

     

       43
       43
       -
            <entry><literal>true</literal>, <literal>false</literal>

     

       44
       44
       -
            </entry>

     

       45
       45
       -
            <entry>Booleans</entry>

     

       46
       46
       -
           </row>

     

       47
       47
       -
           <row>

     

       48
       48
       -
            <entry><literal>123</literal>

     

       49
       49
       -
            </entry>

     

       50
       50
       -
            <entry>An integer</entry>

     

       51
       51
       -
           </row>

     

       52
       52
       -
           <row>

     

       53
       53
       -
            <entry><literal>./foo.png</literal>

     

       54
       54
       -
            </entry>

     

       55
       55
       -
            <entry>A path (relative to the containing Nix expression)</entry>

     

       56
       56
       -
           </row>

     

       57
       57
       -
           <row>

     

       58
       58
       -
            <entry namest="c1" nameend="c2"><emphasis>Compound values</emphasis>

     

       59
       59
       -
            </entry>

     

       60
       60
       -
           </row>

     

       61
       61
       -
           <row>

     

       62
       62
       -
            <entry><literal>{ x = 1; y = 2; }</literal>

     

       63
       63
       -
            </entry>

     

       64
       64
       -
            <entry>A set with attributes named <literal>x</literal> and <literal>y</literal>

     

       65
       65
       -
            </entry>

     

       66
       66
       -
           </row>

     

       67
       67
       -
           <row>

     

       68
       68
       -
            <entry><literal>{ foo.bar = 1; }</literal>

     

       69
       69
       -
            </entry>

     

       70
       70
       -
            <entry>A nested set, equivalent to <literal>{ foo = { bar = 1; }; }</literal>

     

       71
       71
       -
            </entry>

     

       72
       72
       -
           </row>

     

       73
       73
       -
           <row>

     

       74
       74
       -
            <entry><literal>rec { x = "foo"; y = x + "bar"; }</literal>

     

       75
       75
       -
            </entry>

     

       76
       76
       -
            <entry>A recursive set, equivalent to <literal>{ x = "foo"; y = "foobar"; }</literal>

     

       77
       77
       -
            </entry>

     

       78
       78
       -
           </row>

     

       79
       79
       -
           <row>

     

       80
       80
       -
            <entry><literal>[ "foo" "bar" ]</literal>

     

       81
       81
       -
            </entry>

     

       82
       82
       -
            <entry>A list with two elements</entry>

     

       83
       83
       -
           </row>

     

       84
       84
       -
           <row>

     

       85
       85
       -
            <entry namest="c1" nameend="c2"><emphasis>Operators</emphasis>

     

       86
       86
       -
            </entry>

     

       87
       87
       -
           </row>

     

       88
       88
       -
           <row>

     

       89
       89
       -
            <entry><literal>"foo" + "bar"</literal>

     

       90
       90
       -
            </entry>

     

       91
       91
       -
            <entry>String concatenation</entry>

     

       92
       92
       -
           </row>

     

       93
       93
       -
           <row>

     

       94
       94
       -
            <entry><literal>1 + 2</literal>

     

       95
       95
       -
            </entry>

     

       96
       96
       -
            <entry>Integer addition</entry>

     

       97
       97
       -
           </row>

     

       98
       98
       -
           <row>

     

       99
       99
       -
            <entry><literal>"foo" == "f" + "oo"</literal>

     

       100
       100
       -
            </entry>

     

       101
       101
       -
            <entry>Equality test (evaluates to <literal>true</literal>)</entry>

     

       102
       102
       -
           </row>

     

       103
       103
       -
           <row>

     

       104
       104
       -
            <entry><literal>"foo" != "bar"</literal>

     

       105
       105
       -
            </entry>

     

       106
       106
       -
            <entry>Inequality test (evaluates to <literal>true</literal>)</entry>

     

       107
       107
       -
           </row>

     

       108
       108
       -
           <row>

     

       109
       109
       -
            <entry><literal>!true</literal>

     

       110
       110
       -
            </entry>

     

       111
       111
       -
            <entry>Boolean negation</entry>

     

       112
       112
       -
           </row>

     

       113
       113
       -
           <row>

     

       114
       114
       -
            <entry><literal>{ x = 1; y = 2; }.x</literal>

     

       115
       115
       -
            </entry>

     

       116
       116
       -
            <entry>Attribute selection (evaluates to <literal>1</literal>)</entry>

     

       117
       117
       -
           </row>

     

       118
       118
       -
           <row>

     

       119
       119
       -
            <entry><literal>{ x = 1; y = 2; }.z or 3</literal>

     

       120
       120
       -
            </entry>

     

       121
       121
       -
            <entry>Attribute selection with default (evaluates to <literal>3</literal>)</entry>

     

       122
       122
       -
           </row>

     

       123
       123
       -
           <row>

     

       124
       124
       -
            <entry><literal>{ x = 1; y = 2; } // { z = 3; }</literal>

     

       125
       125
       -
            </entry>

     

       126
       126
       -
            <entry>Merge two sets (attributes in the right-hand set taking precedence)</entry>

     

       127
       127
       -
           </row>

     

       128
       128
       -
           <row>

     

       129
       129
       -
            <entry namest="c1" nameend="c2"><emphasis>Control structures</emphasis>

     

       130
       130
       -
            </entry>

     

       131
       131
       -
           </row>

     

       132
       132
       -
           <row>

     

       133
       133
       -
            <entry><literal>if 1 + 1 == 2 then "yes!" else "no!"</literal>

     

       134
       134
       -
            </entry>

     

       135
       135
       -
            <entry>Conditional expression</entry>

     

       136
       136
       -
           </row>

     

       137
       137
       -
           <row>

     

       138
       138
       -
            <entry><literal>assert 1 + 1 == 2; "yes!"</literal>

     

       139
       139
       -
            </entry>

     

       140
       140
       -
            <entry>Assertion check (evaluates to <literal>"yes!"</literal>). See <xref

     

       141
       141
       -
           linkend="sec-assertions"/> for using assertions in modules</entry>

     

       142
       142
       -
           </row>

     

       143
       143
       -
           <row>

     

       144
       144
       -
            <entry><literal>let x = "foo"; y = "bar"; in x + y</literal>

     

       145
       145
       -
            </entry>

     

       146
       146
       -
            <entry>Variable definition</entry>

     

       147
       147
       -
           </row>

     

       148
       148
       -
           <row>

     

       149
       149
       -
            <entry><literal>with pkgs.lib; head [ 1 2 3 ]</literal>

     

       150
       150
       -
            </entry>

     

       151
       151
       -
            <entry>Add all attributes from the given set to the scope

     

       152
       152
       -
               (evaluates to <literal>1</literal>)</entry>

     

       153
       153
       -
           </row>

     

       154
       154
       -
           <row>

     

       155
       155
       -
            <entry namest="c1" nameend="c2"><emphasis>Functions (lambdas)</emphasis>

     

       156
       156
       -
            </entry>

     

       157
       157
       -
           </row>

     

       158
       158
       -
           <row>

     

       159
       159
       -
            <entry><literal>x: x + 1</literal>

     

       160
       160
       -
            </entry>

     

       161
       161
       -
            <entry>A function that expects an integer and returns it increased by 1</entry>

     

       162
       162
       -
           </row>

     

       163
       163
       -
           <row>

     

       164
       164
       -
            <entry><literal>(x: x + 1) 100</literal>

     

       165
       165
       -
            </entry>

     

       166
       166
       -
            <entry>A function call (evaluates to 101)</entry>

     

       167
       167
       -
           </row>

     

       168
       168
       -
           <row>

     

       169
       169
       -
            <entry><literal>let inc = x: x + 1; in inc (inc (inc 100))</literal>

     

       170
       170
       -
            </entry>

     

       171
       171
       -
            <entry>A function bound to a variable and subsequently called by name (evaluates to 103)</entry>

     

       172
       172
       -
           </row>

     

       173
       173
       -
           <row>

     

       174
       174
       -
            <entry><literal>{ x, y }: x + y</literal>

     

       175
       175
       -
            </entry>

     

       176
       176
       -
            <entry>A function that expects a set with required attributes

     

       177
       177
       -
               <literal>x</literal> and <literal>y</literal> and concatenates

     

       178
       178
       -
               them</entry>

     

       179
       179
       -
           </row>

     

       180
       180
       -
           <row>

     

       181
       181
       -
            <entry><literal>{ x, y ? "bar" }: x + y</literal>

     

       182
       182
       -
            </entry>

     

       183
       183
       -
            <entry>A function that expects a set with required attribute

     

       184
       184
       -
               <literal>x</literal> and optional <literal>y</literal>, using

     

       185
       185
       -
               <literal>"bar"</literal> as default value for

     

       186
       186
       -
               <literal>y</literal>

     

       187
       187
       -
            </entry>

     

       188
       188
       -
           </row>

     

       189
       189
       -
           <row>

     

       190
       190
       -
            <entry><literal>{ x, y, ... }: x + y</literal>

     

       191
       191
       -
            </entry>

     

       192
       192
       -
            <entry>A function that expects a set with required attributes

     

       193
       193
       -
               <literal>x</literal> and <literal>y</literal> and ignores any

     

       194
       194
       -
               other attributes</entry>

     

       195
       195
       -
           </row>

     

       196
       196
       -
           <row>

     

       197
       197
       -
            <entry><literal>{ x, y } @ args: x + y</literal>

     

       198
       198
       -
            </entry>

     

       199
       199
       -
            <entry>A function that expects a set with required attributes

     

       200
       200
       -
               <literal>x</literal> and <literal>y</literal>, and binds the

     

       201
       201
       -
               whole set to <literal>args</literal>

     

       202
       202
       -
            </entry>

     

       203
       203
       -
           </row>

     

       204
       204
       -
           <row>

     

       205
       205
       -
            <entry namest="c1" nameend="c2"><emphasis>Built-in functions</emphasis>

     

       206
       206
       -
            </entry>

     

       207
       207
       -
           </row>

     

       208
       208
       -
           <row>

     

       209
       209
       -
            <entry><literal>import ./foo.nix</literal>

     

       210
       210
       -
            </entry>

     

       211
       211
       -
            <entry>Load and return Nix expression in given file</entry>

     

       212
       212
       -
           </row>

     

       213
       213
       -
           <row>

     

       214
       214
       -
            <entry><literal>map (x: x + x) [ 1 2 3 ]</literal>

     

       215
       215
       -
            </entry>

     

       216
       216
       -
            <entry>Apply a function to every element of a list (evaluates to <literal>[ 2 4 6 ]</literal>)</entry>

     

       217
       217
       -
           </row>

     

       218
       218
       -
       <!--

     

       219
       219
       -
             <row>

     

       220
       220
       -
               <entry><literal>throw "Urgh"</literal></entry>

     

       221
       221
       -
               <entry>Raise an error condition</entry>

     

       222
       222
       -
             </row>

     

       223
       223
       -
             -->

     

       224
       224
       -
          </tbody>

     

       225
       225
       -
         </tgroup>

     

       226
       226
       -
        </informaltable>

     

       227
       227
       -
       </section>

+332

nixos/doc/manual/from_md/configuration/summary.section.xml

···

       1
       1
       +
       <section xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xml:id="sec-nix-syntax-summary">

     

       2
       2
       +
         <title>Syntax Summary</title>

     

       3
       3
       +
         <para>

     

       4
       4
       +
           Below is a summary of the most important syntactic constructs in the

     

       5
       5
       +
           Nix expression language. It’s not complete. In particular, there are

     

       6
       6
       +
           many other built-in functions. See the

     

       7
       7
       +
           <link xlink:href="https://nixos.org/nix/manual/#chap-writing-nix-expressions">Nix

     

       8
       8
       +
           manual</link> for the rest.

     

       9
       9
       +
         </para>

     

       10
       10
       +
         <informaltable>

     

       11
       11
       +
           <tgroup cols="2">

     

       12
       12
       +
             <colspec align="left" />

     

       13
       13
       +
             <colspec align="left" />

     

       14
       14
       +
             <thead>

     

       15
       15
       +
               <row>

     

       16
       16
       +
                 <entry>

     

       17
       17
       +
                   Example

     

       18
       18
       +
                 </entry>

     

       19
       19
       +
                 <entry>

     

       20
       20
       +
                   Description

     

       21
       21
       +
                 </entry>

     

       22
       22
       +
               </row>

     

       23
       23
       +
             </thead>

     

       24
       24
       +
             <tbody>

     

       25
       25
       +
               <row>

     

       26
       26
       +
                 <entry>

     

       27
       27
       +
                   <emphasis>Basic values</emphasis>

     

       28
       28
       +
                 </entry>

     

       29
       29
       +
                 <entry>

     

       30
       30
       +
                 </entry>

     

       31
       31
       +
               </row>

     

       32
       32
       +
               <row>

     

       33
       33
       +
                 <entry>

     

       34
       34
       +
                   <literal>&quot;Hello world&quot;</literal>

     

       35
       35
       +
                 </entry>

     

       36
       36
       +
                 <entry>

     

       37
       37
       +
                   A string

     

       38
       38
       +
                 </entry>

     

       39
       39
       +
               </row>

     

       40
       40
       +
               <row>

     

       41
       41
       +
                 <entry>

     

       42
       42
       +
                   <literal>&quot;${pkgs.bash}/bin/sh&quot;</literal>

     

       43
       43
       +
                 </entry>

     

       44
       44
       +
                 <entry>

     

       45
       45
       +
                   A string containing an expression (expands to

     

       46
       46
       +
                   <literal>&quot;/nix/store/hash-bash-version/bin/sh&quot;</literal>)

     

       47
       47
       +
                 </entry>

     

       48
       48
       +
               </row>

     

       49
       49
       +
               <row>

     

       50
       50
       +
                 <entry>

     

       51
       51
       +
                   <literal>true</literal>, <literal>false</literal>

     

       52
       52
       +
                 </entry>

     

       53
       53
       +
                 <entry>

     

       54
       54
       +
                   Booleans

     

       55
       55
       +
                 </entry>

     

       56
       56
       +
               </row>

     

       57
       57
       +
               <row>

     

       58
       58
       +
                 <entry>

     

       59
       59
       +
                   <literal>123</literal>

     

       60
       60
       +
                 </entry>

     

       61
       61
       +
                 <entry>

     

       62
       62
       +
                   An integer

     

       63
       63
       +
                 </entry>

     

       64
       64
       +
               </row>

     

       65
       65
       +
               <row>

     

       66
       66
       +
                 <entry>

     

       67
       67
       +
                   <literal>./foo.png</literal>

     

       68
       68
       +
                 </entry>

     

       69
       69
       +
                 <entry>

     

       70
       70
       +
                   A path (relative to the containing Nix expression)

     

       71
       71
       +
                 </entry>

     

       72
       72
       +
               </row>

     

       73
       73
       +
               <row>

     

       74
       74
       +
                 <entry>

     

       75
       75
       +
                   <emphasis>Compound values</emphasis>

     

       76
       76
       +
                 </entry>

     

       77
       77
       +
                 <entry>

     

       78
       78
       +
                 </entry>

     

       79
       79
       +
               </row>

     

       80
       80
       +
               <row>

     

       81
       81
       +
                 <entry>

     

       82
       82
       +
                   <literal>{ x = 1; y = 2; }</literal>

     

       83
       83
       +
                 </entry>

     

       84
       84
       +
                 <entry>

     

       85
       85
       +
                   A set with attributes named <literal>x</literal> and

     

       86
       86
       +
                   <literal>y</literal>

     

       87
       87
       +
                 </entry>

     

       88
       88
       +
               </row>

     

       89
       89
       +
               <row>

     

       90
       90
       +
                 <entry>

     

       91
       91
       +
                   <literal>{ foo.bar = 1; }</literal>

     

       92
       92
       +
                 </entry>

     

       93
       93
       +
                 <entry>

     

       94
       94
       +
                   A nested set, equivalent to

     

       95
       95
       +
                   <literal>{ foo = { bar = 1; }; }</literal>

     

       96
       96
       +
                 </entry>

     

       97
       97
       +
               </row>

     

       98
       98
       +
               <row>

     

       99
       99
       +
                 <entry>

     

       100
       100
       +
                   <literal>rec { x = &quot;foo&quot;; y = x + &quot;bar&quot;; }</literal>

     

       101
       101
       +
                 </entry>

     

       102
       102
       +
                 <entry>

     

       103
       103
       +
                   A recursive set, equivalent to

     

       104
       104
       +
                   <literal>{ x = &quot;foo&quot;; y = &quot;foobar&quot;; }</literal>

     

       105
       105
       +
                 </entry>

     

       106
       106
       +
               </row>

     

       107
       107
       +
               <row>

     

       108
       108
       +
                 <entry>

     

       109
       109
       +
                   <literal>[ &quot;foo&quot; &quot;bar&quot; ]</literal>

     

       110
       110
       +
                 </entry>

     

       111
       111
       +
                 <entry>

     

       112
       112
       +
                   A list with two elements

     

       113
       113
       +
                 </entry>

     

       114
       114
       +
               </row>

     

       115
       115
       +
               <row>

     

       116
       116
       +
                 <entry>

     

       117
       117
       +
                   <emphasis>Operators</emphasis>

     

       118
       118
       +
                 </entry>

     

       119
       119
       +
                 <entry>

     

       120
       120
       +
                 </entry>

     

       121
       121
       +
               </row>

     

       122
       122
       +
               <row>

     

       123
       123
       +
                 <entry>

     

       124
       124
       +
                   <literal>&quot;foo&quot; + &quot;bar&quot;</literal>

     

       125
       125
       +
                 </entry>

     

       126
       126
       +
                 <entry>

     

       127
       127
       +
                   String concatenation

     

       128
       128
       +
                 </entry>

     

       129
       129
       +
               </row>

     

       130
       130
       +
               <row>

     

       131
       131
       +
                 <entry>

     

       132
       132
       +
                   <literal>1 + 2</literal>

     

       133
       133
       +
                 </entry>

     

       134
       134
       +
                 <entry>

     

       135
       135
       +
                   Integer addition

     

       136
       136
       +
                 </entry>

     

       137
       137
       +
               </row>

     

       138
       138
       +
               <row>

     

       139
       139
       +
                 <entry>

     

       140
       140
       +
                   <literal>&quot;foo&quot; == &quot;f&quot; + &quot;oo&quot;</literal>

     

       141
       141
       +
                 </entry>

     

       142
       142
       +
                 <entry>

     

       143
       143
       +
                   Equality test (evaluates to <literal>true</literal>)

     

       144
       144
       +
                 </entry>

     

       145
       145
       +
               </row>

     

       146
       146
       +
               <row>

     

       147
       147
       +
                 <entry>

     

       148
       148
       +
                   <literal>&quot;foo&quot; != &quot;bar&quot;</literal>

     

       149
       149
       +
                 </entry>

     

       150
       150
       +
                 <entry>

     

       151
       151
       +
                   Inequality test (evaluates to <literal>true</literal>)

     

       152
       152
       +
                 </entry>

     

       153
       153
       +
               </row>

     

       154
       154
       +
               <row>

     

       155
       155
       +
                 <entry>

     

       156
       156
       +
                   <literal>!true</literal>

     

       157
       157
       +
                 </entry>

     

       158
       158
       +
                 <entry>

     

       159
       159
       +
                   Boolean negation

     

       160
       160
       +
                 </entry>

     

       161
       161
       +
               </row>

     

       162
       162
       +
               <row>

     

       163
       163
       +
                 <entry>

     

       164
       164
       +
                   <literal>{ x = 1; y = 2; }.x</literal>

     

       165
       165
       +
                 </entry>

     

       166
       166
       +
                 <entry>

     

       167
       167
       +
                   Attribute selection (evaluates to <literal>1</literal>)

     

       168
       168
       +
                 </entry>

     

       169
       169
       +
               </row>

     

       170
       170
       +
               <row>

     

       171
       171
       +
                 <entry>

     

       172
       172
       +
                   <literal>{ x = 1; y = 2; }.z or 3</literal>

     

       173
       173
       +
                 </entry>

     

       174
       174
       +
                 <entry>

     

       175
       175
       +
                   Attribute selection with default (evaluates to

     

       176
       176
       +
                   <literal>3</literal>)

     

       177
       177
       +
                 </entry>

     

       178
       178
       +
               </row>

     

       179
       179
       +
               <row>

     

       180
       180
       +
                 <entry>

     

       181
       181
       +
                   <literal>{ x = 1; y = 2; } // { z = 3; }</literal>

     

       182
       182
       +
                 </entry>

     

       183
       183
       +
                 <entry>

     

       184
       184
       +
                   Merge two sets (attributes in the right-hand set taking

     

       185
       185
       +
                   precedence)

     

       186
       186
       +
                 </entry>

     

       187
       187
       +
               </row>

     

       188
       188
       +
               <row>

     

       189
       189
       +
                 <entry>

     

       190
       190
       +
                   <emphasis>Control structures</emphasis>

     

       191
       191
       +
                 </entry>

     

       192
       192
       +
                 <entry>

     

       193
       193
       +
                 </entry>

     

       194
       194
       +
               </row>

     

       195
       195
       +
               <row>

     

       196
       196
       +
                 <entry>

     

       197
       197
       +
                   <literal>if 1 + 1 == 2 then &quot;yes!&quot; else &quot;no!&quot;</literal>

     

       198
       198
       +
                 </entry>

     

       199
       199
       +
                 <entry>

     

       200
       200
       +
                   Conditional expression

     

       201
       201
       +
                 </entry>

     

       202
       202
       +
               </row>

     

       203
       203
       +
               <row>

     

       204
       204
       +
                 <entry>

     

       205
       205
       +
                   <literal>assert 1 + 1 == 2; &quot;yes!&quot;</literal>

     

       206
       206
       +
                 </entry>

     

       207
       207
       +
                 <entry>

     

       208
       208
       +
                   Assertion check (evaluates to

     

       209
       209
       +
                   <literal>&quot;yes!&quot;</literal>). See

     

       210
       210
       +
                   <xref linkend="sec-assertions" /> for using assertions in

     

       211
       211
       +
                   modules

     

       212
       212
       +
                 </entry>

     

       213
       213
       +
               </row>

     

       214
       214
       +
               <row>

     

       215
       215
       +
                 <entry>

     

       216
       216
       +
                   <literal>let x = &quot;foo&quot;; y = &quot;bar&quot;; in x + y</literal>

     

       217
       217
       +
                 </entry>

     

       218
       218
       +
                 <entry>

     

       219
       219
       +
                   Variable definition

     

       220
       220
       +
                 </entry>

     

       221
       221
       +
               </row>

     

       222
       222
       +
               <row>

     

       223
       223
       +
                 <entry>

     

       224
       224
       +
                   <literal>with pkgs.lib; head [ 1 2 3 ]</literal>

     

       225
       225
       +
                 </entry>

     

       226
       226
       +
                 <entry>

     

       227
       227
       +
                   Add all attributes from the given set to the scope

     

       228
       228
       +
                   (evaluates to <literal>1</literal>)

     

       229
       229
       +
                 </entry>

     

       230
       230
       +
               </row>

     

       231
       231
       +
               <row>

     

       232
       232
       +
                 <entry>

     

       233
       233
       +
                   <emphasis>Functions (lambdas)</emphasis>

     

       234
       234
       +
                 </entry>

     

       235
       235
       +
                 <entry>

     

       236
       236
       +
                 </entry>

     

       237
       237
       +
               </row>

     

       238
       238
       +
               <row>

     

       239
       239
       +
                 <entry>

     

       240
       240
       +
                   <literal>x: x + 1</literal>

     

       241
       241
       +
                 </entry>

     

       242
       242
       +
                 <entry>

     

       243
       243
       +
                   A function that expects an integer and returns it increased

     

       244
       244
       +
                   by 1

     

       245
       245
       +
                 </entry>

     

       246
       246
       +
               </row>

     

       247
       247
       +
               <row>

     

       248
       248
       +
                 <entry>

     

       249
       249
       +
                   <literal>(x: x + 1) 100</literal>

     

       250
       250
       +
                 </entry>

     

       251
       251
       +
                 <entry>

     

       252
       252
       +
                   A function call (evaluates to 101)

     

       253
       253
       +
                 </entry>

     

       254
       254
       +
               </row>

     

       255
       255
       +
               <row>

     

       256
       256
       +
                 <entry>

     

       257
       257
       +
                   <literal>let inc = x: x + 1; in inc (inc (inc 100))</literal>

     

       258
       258
       +
                 </entry>

     

       259
       259
       +
                 <entry>

     

       260
       260
       +
                   A function bound to a variable and subsequently called by

     

       261
       261
       +
                   name (evaluates to 103)

     

       262
       262
       +
                 </entry>

     

       263
       263
       +
               </row>

     

       264
       264
       +
               <row>

     

       265
       265
       +
                 <entry>

     

       266
       266
       +
                   <literal>{ x, y }: x + y</literal>

     

       267
       267
       +
                 </entry>

     

       268
       268
       +
                 <entry>

     

       269
       269
       +
                   A function that expects a set with required attributes

     

       270
       270
       +
                   <literal>x</literal> and <literal>y</literal> and

     

       271
       271
       +
                   concatenates them

     

       272
       272
       +
                 </entry>

     

       273
       273
       +
               </row>

     

       274
       274
       +
               <row>

     

       275
       275
       +
                 <entry>

     

       276
       276
       +
                   <literal>{ x, y ? &quot;bar&quot; }: x + y</literal>

     

       277
       277
       +
                 </entry>

     

       278
       278
       +
                 <entry>

     

       279
       279
       +
                   A function that expects a set with required attribute

     

       280
       280
       +
                   <literal>x</literal> and optional <literal>y</literal>,

     

       281
       281
       +
                   using <literal>&quot;bar&quot;</literal> as default value

     

       282
       282
       +
                   for <literal>y</literal>

     

       283
       283
       +
                 </entry>

     

       284
       284
       +
               </row>

     

       285
       285
       +
               <row>

     

       286
       286
       +
                 <entry>

     

       287
       287
       +
                   <literal>{ x, y, ... }: x + y</literal>

     

       288
       288
       +
                 </entry>

     

       289
       289
       +
                 <entry>

     

       290
       290
       +
                   A function that expects a set with required attributes

     

       291
       291
       +
                   <literal>x</literal> and <literal>y</literal> and ignores

     

       292
       292
       +
                   any other attributes

     

       293
       293
       +
                 </entry>

     

       294
       294
       +
               </row>

     

       295
       295
       +
               <row>

     

       296
       296
       +
                 <entry>

     

       297
       297
       +
                   <literal>{ x, y } @ args: x + y</literal>

     

       298
       298
       +
                 </entry>

     

       299
       299
       +
                 <entry>

     

       300
       300
       +
                   A function that expects a set with required attributes

     

       301
       301
       +
                   <literal>x</literal> and <literal>y</literal>, and binds the

     

       302
       302
       +
                   whole set to <literal>args</literal>

     

       303
       303
       +
                 </entry>

     

       304
       304
       +
               </row>

     

       305
       305
       +
               <row>

     

       306
       306
       +
                 <entry>

     

       307
       307
       +
                   <emphasis>Built-in functions</emphasis>

     

       308
       308
       +
                 </entry>

     

       309
       309
       +
                 <entry>

     

       310
       310
       +
                 </entry>

     

       311
       311
       +
               </row>

     

       312
       312
       +
               <row>

     

       313
       313
       +
                 <entry>

     

       314
       314
       +
                   <literal>import ./foo.nix</literal>

     

       315
       315
       +
                 </entry>

     

       316
       316
       +
                 <entry>

     

       317
       317
       +
                   Load and return Nix expression in given file

     

       318
       318
       +
                 </entry>

     

       319
       319
       +
               </row>

     

       320
       320
       +
               <row>

     

       321
       321
       +
                 <entry>

     

       322
       322
       +
                   <literal>map (x: x + x) [ 1 2 3 ]</literal>

     

       323
       323
       +
                 </entry>

     

       324
       324
       +
                 <entry>

     

       325
       325
       +
                   Apply a function to every element of a list (evaluates to

     

       326
       326
       +
                   <literal>[ 2 4 6 ]</literal>)

     

       327
       327
       +
                 </entry>

     

       328
       328
       +
               </row>

     

       329
       329
       +
             </tbody>

     

       330
       330
       +
           </tgroup>

     

       331
       331
       +
         </informaltable>

     

       332
       332
       +
       </section>