puck/lix
0
0
Fork 0
forked from lix-project/lix
Code Pull requests Activity

<simplesect> -> <section>

Browse source 
Pandoc silently ignores <simplesect>...
This commit is contained in:
Eelco Dolstra 2020-07-23 14:20:54 +02:00
parent 136fd55bb2
commit ee05108472
No known key found for this signature in database
GPG key ID: 8170B4726D7198DE
7 changed files with 82 additions and 54 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

32
doc/manual/expressions/language-constructs.xml
View file

@ -6,7 +6,7 @@
<title>Language Constructs</title> <title>Language Constructs</title>
<simplesect><title>Recursive sets</title> <section><title>Recursive sets</title>
<para>Recursive sets are just normal sets, but the attributes can <para>Recursive sets are just normal sets, but the attributes can
refer to each other. For example, refer to each other. For example,
@ -38,10 +38,10 @@ does not terminate<footnote><para>Actually, Nix detects infinite
recursion in this case and aborts (<quote>infinite recursion recursion in this case and aborts (<quote>infinite recursion
encountered</quote>).</para></footnote>.</para> encountered</quote>).</para></footnote>.</para>
</simplesect> </section>
<simplesect xml:id="sect-let-expressions"><title>Let-expressions</title> <section xml:id="sect-let-expressions"><title>Let-expressions</title>
<para>A let-expression allows you to define local variables for an <para>A let-expression allows you to define local variables for an
expression. For instance, expression. For instance,
@ -56,10 +56,10 @@ evaluates to <literal>"foobar"</literal>.
</para> </para>
</simplesect> </section>
<simplesect><title>Inheriting attributes</title> <section><title>Inheriting attributes</title>
<para>When defining a set or in a let-expression it is often convenient to copy variables <para>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 from the surrounding lexical scope (e.g., when you want to propagate
@ -129,10 +129,10 @@ a = src-set.a; b = src-set.b; c = src-set.c;
when used while defining local variables in a let-expression or when used while defining local variables in a let-expression or
while defining a set.</para> while defining a set.</para>
</simplesect> </section>
<simplesect xml:id="ss-functions"><title>Functions</title> <section xml:id="ss-functions"><title>Functions</title>
<para>Functions have the following form: <para>Functions have the following form:
@ -248,10 +248,10 @@ in concat { x = "foo"; y = "bar"; }</programlisting>
</para> </para>
</simplesect> </section>
<simplesect><title>Conditionals</title> <section><title>Conditionals</title>
<para>Conditionals look like this: <para>Conditionals look like this:
@ -262,10 +262,10 @@ where <replaceable>e1</replaceable> is an expression that should
evaluate to a Boolean value (<literal>true</literal> or evaluate to a Boolean value (<literal>true</literal> or
<literal>false</literal>).</para> <literal>false</literal>).</para>
</simplesect> </section>
<simplesect><title>Assertions</title> <section><title>Assertions</title>
<para>Assertions are generally used to check that certain requirements <para>Assertions are generally used to check that certain requirements
on or between features and dependencies hold. They look like this: on or between features and dependencies hold. They look like this:
@ -349,11 +349,11 @@ stdenv.mkDerivation {
</orderedlist> </orderedlist>
</simplesect> </section>
<simplesect><title>With-expressions</title> <section><title>With-expressions</title>
<para>A <emphasis>with-expression</emphasis>, <para>A <emphasis>with-expression</emphasis>,
@ -394,16 +394,16 @@ let a = 1; in let a = 2; in let a = 3; in let a = 4; in ...</programlisting>
</para> </para>
</simplesect> </section>
<simplesect><title>Comments</title> <section><title>Comments</title>
<para>Comments can be single-line, started with a <literal>#</literal> <para>Comments can be single-line, started with a <literal>#</literal>
character, or inline/multi-line, enclosed within <literal>/* character, or inline/multi-line, enclosed within <literal>/*
... */</literal>.</para> ... */</literal>.</para>
</simplesect> </section>
</section> </section>

12
doc/manual/expressions/language-values.xml
View file

@ -7,7 +7,7 @@
<title>Values</title> <title>Values</title>
<simplesect><title>Simple Values</title> <section><title>Simple Values</title>
<para>Nix has the following basic data types: <para>Nix has the following basic data types:
@ -193,10 +193,10 @@ stdenv.mkDerivation {
</para> </para>
</simplesect> </section>
<simplesect><title>Lists</title> <section><title>Lists</title>
<para>Lists are formed by enclosing a whitespace-separated list of <para>Lists are formed by enclosing a whitespace-separated list of
values between square brackets. For example, values between square brackets. For example,
@ -217,10 +217,10 @@ function and the fifth being a set.</para>
<para>Note that lists are only lazy in values, and they are strict in length. <para>Note that lists are only lazy in values, and they are strict in length.
</para> </para>
</simplesect> </section>
<simplesect><title>Sets</title> <section><title>Sets</title>
<para>Sets are really the core of the language, since ultimately the <para>Sets are really the core of the language, since ultimately the
Nix language is all about creating derivations, which are really just Nix language is all about creating derivations, which are really just
@ -307,7 +307,7 @@ a form of object-oriented programming, for example.
</para> </para>
</simplesect> </section>
</section> </section>

12
doc/manual/installation/multi-user.xml
View file

@ -30,7 +30,7 @@ arbitrary Nix expressions, they may not get pre-built
binaries.</para></note> binaries.</para></note>
<simplesect> <section>
<title>Setting up the build users</title> <title>Setting up the build users</title>
@ -52,10 +52,10 @@ This creates 10 build users. There can never be more concurrent builds
than the number of build users, so you may want to increase this if than the number of build users, so you may want to increase this if
you expect to do many builds at the same time.</para> you expect to do many builds at the same time.</para>
</simplesect> </section>
<simplesect> <section>
<title>Running the daemon</title> <title>Running the daemon</title>
@ -78,10 +78,10 @@ export NIX_REMOTE=daemon</programlisting>
into the users’ login scripts.</para> into the users’ login scripts.</para>
</simplesect> </section>
<simplesect> <section>
<title>Restricting access</title> <title>Restricting access</title>
@ -101,7 +101,7 @@ cannot connect to the Unix domain socket
<filename>/nix/var/nix/daemon-socket/socket</filename>, so they cannot <filename>/nix/var/nix/daemon-socket/socket</filename>, so they cannot
perform Nix operations.</para> perform Nix operations.</para>
</simplesect> </section>
</section> </section>

52
doc/manual/introduction/about-nix.xml
View file

@ -25,7 +25,7 @@ of the package’s build dependency graph). This enables many powerful
features.</para> features.</para>
<simplesect><title>Multiple versions</title> <section><title>Multiple versions</title>
<para>You can have multiple versions or variants of a package <para>You can have multiple versions or variants of a package
installed at the same time. This is especially important when installed at the same time. This is especially important when
@ -39,10 +39,10 @@ uninstalling an application cannot break other applications, since
these operations never “destructively” update or delete files that are these operations never “destructively” update or delete files that are
used by other packages.</para> used by other packages.</para>
</simplesect> </section>
<simplesect><title>Complete dependencies</title> <section><title>Complete dependencies</title>
<para>Nix helps you make sure that package dependency specifications <para>Nix helps you make sure that package dependency specifications
are complete. In general, when you’re making a package for a package are complete. In general, when you’re making a package for a package
@ -68,10 +68,10 @@ scanning binaries for the hash parts of Nix store paths (such as
<literal>r8vvq9kq…</literal>). This sounds risky, but it works <literal>r8vvq9kq…</literal>). This sounds risky, but it works
extremely well.</para> extremely well.</para>
</simplesect> </section>
<simplesect><title>Multi-user support</title> <section><title>Multi-user support</title>
<para>Nix has multi-user support. This means that non-privileged <para>Nix has multi-user support. This means that non-privileged
users can securely install software. Each user can have a different users can securely install software. Each user can have a different
@ -82,10 +82,10 @@ package won’t be built or downloaded a second time. At the same time,
it is not possible for one user to inject a Trojan horse into a it is not possible for one user to inject a Trojan horse into a
package that might be used by another user.</para> package that might be used by another user.</para>
</simplesect> </section>
<simplesect><title>Atomic upgrades and rollbacks</title> <section><title>Atomic upgrades and rollbacks</title>
<para>Since package management operations never overwrite packages in <para>Since package management operations never overwrite packages in
the Nix store but just add new versions in different paths, they are the Nix store but just add new versions in different paths, they are
@ -103,10 +103,10 @@ $ nix-env --upgrade <replaceable>some-packages</replaceable>
$ nix-env --rollback $ nix-env --rollback
</screen> </screen>
</simplesect> </section>
<simplesect><title>Garbage collection</title> <section><title>Garbage collection</title>
<para>When you uninstall a package like this… <para>When you uninstall a package like this…
@ -126,10 +126,10 @@ $ nix-collect-garbage
This deletes all packages that aren’t in use by any user profile or by This deletes all packages that aren’t in use by any user profile or by
a currently running program.</para> a currently running program.</para>
</simplesect> </section>
<simplesect><title>Functional package language</title> <section><title>Functional package language</title>
<para>Packages are built from <emphasis>Nix expressions</emphasis>, <para>Packages are built from <emphasis>Nix expressions</emphasis>,
which is a simple functional language. A Nix expression describes which is a simple functional language. A Nix expression describes
@ -145,10 +145,10 @@ function and call it any number of times with the appropriate
arguments. Due to the hashing scheme, variants don’t conflict with arguments. Due to the hashing scheme, variants don’t conflict with
each other in the Nix store.</para> each other in the Nix store.</para>
</simplesect> </section>
<simplesect><title>Transparent source/binary deployment</title> <section><title>Transparent source/binary deployment</title>
<para>Nix expressions generally describe how to build a package from <para>Nix expressions generally describe how to build a package from
source, so an installation action like source, so an installation action like
@ -172,31 +172,31 @@ Nix would first check if the file
if so, fetch the pre-built binary referenced from there; otherwise, it if so, fetch the pre-built binary referenced from there; otherwise, it
would fall back to building from source.</para> would fall back to building from source.</para>
</simplesect> </section>
<!-- <!--
<simplesect><title>Binary patching</title> <section><title>Binary patching</title>
<para>In addition to downloading binaries automatically if they’re <para>In addition to downloading binaries automatically if they’re
available, Nix can download binary deltas that patch an existing available, Nix can download binary deltas that patch an existing
package in the Nix store into a new version. This speeds up package in the Nix store into a new version. This speeds up
upgrades.</para> upgrades.</para>
</simplesect> </section>
--> -->
<simplesect><title>Nix Packages collection</title> <section><title>Nix Packages collection</title>
<para>We provide a large set of Nix expressions containing hundreds of <para>We provide a large set of Nix expressions containing hundreds of
existing Unix packages, the <emphasis>Nix Packages existing Unix packages, the <emphasis>Nix Packages
collection</emphasis> (Nixpkgs).</para> collection</emphasis> (Nixpkgs).</para>
</simplesect> </section>
<simplesect><title>Managing build environments</title> <section><title>Managing build environments</title>
<para>Nix is extremely useful for developers as it makes it easy to <para>Nix is extremely useful for developers as it makes it easy to
automatically set up the build environment for a package. Given a automatically set up the build environment for a package. Given a
@ -232,17 +232,17 @@ specifications, Nix makes an excellent basis for <a
href="[%root%]hydra">a continuous build system</a>.</para> href="[%root%]hydra">a continuous build system</a>.</para>
--> -->
</simplesect> </section>
<simplesect><title>Portability</title> <section><title>Portability</title>
<para>Nix runs on Linux and macOS.</para> <para>Nix runs on Linux and macOS.</para>
</simplesect> </section>
<simplesect><title>NixOS</title> <section><title>NixOS</title>
<para>NixOS is a Linux distribution based on Nix. It uses Nix not <para>NixOS is a Linux distribution based on Nix. It uses Nix not
just for package management but also to manage the system just for package management but also to manage the system
@ -253,16 +253,16 @@ earlier state. Also, users can install software without root
privileges. For more information and downloads, see the <link privileges. For more information and downloads, see the <link
xlink:href="http://nixos.org/">NixOS homepage</link>.</para> xlink:href="http://nixos.org/">NixOS homepage</link>.</para>
</simplesect> </section>
<simplesect><title>License</title> <section><title>License</title>
<para>Nix is released under the terms of the <link <para>Nix is released under the terms of the <link
xlink:href="http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html">GNU xlink:href="http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html">GNU
LGPLv2.1 or (at your option) any later version</link>.</para> LGPLv2.1 or (at your option) any later version</link>.</para>
</simplesect> </section>
</chapter> </chapter>

16
doc/manual/src/expressions/language-constructs.md
View file

@ -1,5 +1,7 @@
# Language Constructs # Language Constructs
## Recursive sets
Recursive sets are just normal sets, but the attributes can refer to Recursive sets are just normal sets, but the attributes can refer to
each other. For example, each other. For example,
@ -24,6 +26,8 @@ example,
does not terminate\[1\]. does not terminate\[1\].
## Let-expressions
A let-expression allows you to define local variables for an expression. A let-expression allows you to define local variables for an expression.
For instance, For instance,
@ -34,6 +38,8 @@ For instance,
evaluates to `"foobar"`. evaluates to `"foobar"`.
## Inheriting attributes
When defining a set or in a let-expression it is often convenient to 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 copy variables from the surrounding lexical scope (e.g., when you want
to propagate attributes). This can be shortened using the `inherit` to propagate attributes). This can be shortened using the `inherit`
@ -95,6 +101,8 @@ is equivalent to
when used while defining local variables in a let-expression or while when used while defining local variables in a let-expression or while
defining a set. defining a set.
## Functions
Functions have the following form: Functions have the following form:
pattern: body pattern: body
@ -187,6 +195,8 @@ you can bind them to an attribute, e.g.,
let concat = { x, y }: x + y; let concat = { x, y }: x + y;
in concat { x = "foo"; y = "bar"; } in concat { x = "foo"; y = "bar"; }
## Conditionals
Conditionals look like this: Conditionals look like this:
if e1 then e2 else e3 if e1 then e2 else e3
@ -194,6 +204,8 @@ Conditionals look like this:
where e1 is an expression that should evaluate to a Boolean value where e1 is an expression that should evaluate to a Boolean value
(`true` or `false`). (`true` or `false`).
## Assertions
Assertions are generally used to check that certain requirements on or Assertions are generally used to check that certain requirements on or
between features and dependencies hold. They look like this: between features and dependencies hold. They look like this:
@ -257,6 +269,8 @@ The points of interest are:
non-`null` value was passed. This prevents an unnecessary rebuild of non-`null` value was passed. This prevents an unnecessary rebuild of
Subversion if OpenSSL changes. Subversion if OpenSSL changes.
## With-expressions
A *with-expression*, A *with-expression*,
with e1; e2 with e1; e2
@ -285,6 +299,8 @@ establishes the same scope as
let a = 1; in let a = 2; in let a = 3; in let a = 4; in ... let a = 1; in let a = 2; in let a = 3; in let a = 4; in ...
## Comments
Comments can be single-line, started with a `#` character, or Comments can be single-line, started with a `#` character, or
inline/multi-line, enclosed within `/* inline/multi-line, enclosed within `/*
... */`. ... */`.

6
doc/manual/src/expressions/language-values.md
View file

@ -1,5 +1,7 @@
# Values # Values
## Simple Values
Nix has the following basic data types: Nix has the following basic data types:
- *Strings* can be written in three ways. - *Strings* can be written in three ways.
@ -127,6 +129,8 @@ Nix has the following basic data types:
- The null value, denoted as `null`. - The null value, denoted as `null`.
## Lists
Lists are formed by enclosing a whitespace-separated list of values Lists are formed by enclosing a whitespace-separated list of values
between square brackets. For example, between square brackets. For example,
@ -143,6 +147,8 @@ function and the fifth being a set.
Note that lists are only lazy in values, and they are strict in length. Note that lists are only lazy in values, and they are strict in length.
## Sets
Sets are really the core of the language, since ultimately the Nix Sets are really the core of the language, since ultimately the Nix
language is all about creating derivations, which are really just sets language is all about creating derivations, which are really just sets
of attributes to be passed to build scripts. of attributes to be passed to build scripts.

6
doc/manual/src/installation/multi-user.md
View file

@ -20,6 +20,8 @@ Nix store/database that performs the operation.
> caches. So while unprivileged users may install packages from > caches. So while unprivileged users may install packages from
> arbitrary Nix expressions, they may not get pre-built binaries. > arbitrary Nix expressions, they may not get pre-built binaries.
## Setting up the build users
The *build users* are the special UIDs under which builds are performed. The *build users* are the special UIDs under which builds are performed.
They should all be members of the *build users group* `nixbld`. This They should all be members of the *build users group* `nixbld`. This
group should have no other members. The build users should not be group should have no other members. The build users should not be
@ -35,6 +37,8 @@ This creates 10 build users. There can never be more concurrent builds
than the number of build users, so you may want to increase this if you than the number of build users, so you may want to increase this if you
expect to do many builds at the same time. expect to do many builds at the same time.
## Running the daemon
The [Nix daemon](#sec-nix-daemon) should be started as follows (as The [Nix daemon](#sec-nix-daemon) should be started as follows (as
`root`): `root`):
@ -50,6 +54,8 @@ should put a line like
into the users’ login scripts. into the users’ login scripts.
## Restricting access
To limit which users can perform Nix operations, you can use the To limit which users can perform Nix operations, you can use the
permissions on the directory `/nix/var/nix/daemon-socket`. For instance, permissions on the directory `/nix/var/nix/daemon-socket`. For instance,
if you want to restrict the use of Nix to the members of a group called if you want to restrict the use of Nix to the members of a group called