Skip to content

Commit 837ed69

Browse files
sfermigiersfermigier
committed
WIP: draft content for Nix book.
1 parent 00f133e commit 837ed69

File tree

3 files changed

+222
-0
lines changed

3 files changed

+222
-0
lines changed

‎nixos/README.md

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -23,5 +23,9 @@ Enfin, nous explorerons les capacités avancées de Nix et NixOS. Cela inclut la
2323
- [Introduction](./chap02.md)
2424
- [Concepts fondamentaux](./chap03.md)
2525
- [Installation et configuration](./chap04.md)
26+
27+
Chapitres en cours de rédaction / révision:
28+
29+
- [Le langage Nix](./chap97.md)
2630
- [Flakes](./chap98.md)
2731
- [Appendice 1: La thèse de Dolstra](./chap99.md)

‎nixos/chap97.md

Lines changed: 211 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,211 @@
1+
# Nix, le language
2+
3+
## References:
4+
5+
https://zero-to-nix.com/concepts/nix-language
6+
7+
## Dans ce chapitre
8+
9+
- Aperçu du langage de programmation Nix
10+
- Les constructions du langage : littéraux, opérateurs, variables et fonctions
11+
- Gestion conditionnelle et utilisation des mots-clés `inherit` et `with`
12+
- Importation et chemins dans Nix
13+
- Bibliothèques standard de Nix
14+
- Fonctionnement des dérivations
15+
- Idiomes courants dans Nix
16+
17+
## Introduction au Langage Nix
18+
19+
Le gestionnaire de paquets Nix repose sur un langage de programmation éponyme. Ce langage est essentiel pour la définition, la construction, et la gestion des paquets ainsi que de leurs dépendances. Nix, le langage, est un langage fonctionnel, purement destiné à la gestion des paquets et des configurations de systèmes.
20+
21+
### Caractéristiques Principales du Langage Nix
22+
23+
Nix est conçu spécifiquement pour répondre aux besoins du gestionnaire de paquets Nix et offre des concepts uniques :
24+
25+
1. **Fonctionnel pur** : Chaque expression Nix est immuable et ne produit pas d'effets de bord. Cela garantit que l'évaluation d'une expression avec les mêmes arguments retournera toujours le même résultat, essentiel pour la reproductibilité des systèmes.
26+
27+
2. **Évaluation paresseuse** : Nix n'évalue les expressions que lorsque leur résultat est explicitement demandé. Cela permet une gestion optimisée des ressources, et une flexibilité accrue pour gérer des configurations complexes.
28+
29+
3. **Spécifique à son domaine** : Contrairement aux langages de programmation généralistes, Nix est entièrement dédié à la gestion des paquets et des environnements de développement. Il n'est pas conçu pour d'autres usages en dehors de ce contexte.
30+
31+
## Constructions du Langage
32+
33+
### Littéraux et Types de Données
34+
35+
Le langage Nix comporte plusieurs types de données, représentés par des littéraux dans le code source.
36+
37+
```nix
38+
# Exemples de types de données
39+
42 # Nombre entier
40+
1.72394 # Nombre flottant
41+
"hello" # Chaîne de caractères
42+
./fichier.json # Chemin relatif vers un fichier
43+
44+
# Listes
45+
[ 1 2 3 ]
46+
47+
# Ensembles d'attributs
48+
{ a = 15; b = "autre chose"; }
49+
50+
# Ensembles d'attributs récursifs
51+
rec { a = 15; b = a * 2; }
52+
```
53+
54+
### Opérateurs
55+
56+
Nix comprend plusieurs opérateurs communs à de nombreux langages de programmation. Voici quelques exemples :
57+
58+
| Syntaxe | Description |
59+
|--------------------------|------------------------------------------------|
60+
| `+`, `-`, `*`, `/` | Opérations numériques |
61+
| `++` | Concatenation de listes |
62+
| `==`, `>`, `>=`, `<`, `<=`| Comparateurs d'égalité et d'ordre |
63+
| `&&`, <code>&vert;&vert;</code>| Opérateurs logiques |
64+
| `!` | Négation logique |
65+
| `//` | Fusion d'ensembles d'attributs |
66+
67+
#### L'opérateur `//` (Fusion)
68+
69+
L'opérateur `//` est utilisé pour fusionner deux ensembles d'attributs, le second prenant la priorité en cas de conflit.
70+
71+
```nix
72+
{ a = 1; } // { b = 2; }
73+
# Résultat : { a = 1; b = 2; }
74+
75+
{ a = "gauche"; } // { a = "droite"; }
76+
# Résultat : { a = "droite"; }
77+
```
78+
79+
### Liens de Variables
80+
81+
Nix utilise les expressions `let ... in` pour créer des variables locales dans un certain contexte :
82+
83+
```nix
84+
let
85+
a = 15;
86+
b = 2;
87+
in a * b
88+
# Résultat : 30
89+
```
90+
91+
Les variables sont immuables, et leurs valeurs ne peuvent être modifiées une fois définies.
92+
93+
### Fonctions
94+
95+
Les fonctions dans Nix sont des lambdas anonymes et prennent un seul argument par défaut (les fonctions à arguments multiples sont simulées par *currying* ou en utilisant des ensembles d'attributs).
96+
97+
```nix
98+
name: "Bonjour ${name}"
99+
```
100+
101+
#### Currying (Fonctions à plusieurs arguments)
102+
103+
Nix utilise le currying pour traiter plusieurs arguments :
104+
105+
```nix
106+
name: age: "${name} a ${toString age} ans"
107+
```
108+
109+
Il est aussi possible d'utiliser des ensembles d'attributs pour accepter plusieurs arguments :
110+
111+
```nix
112+
{ name, age }: "${name} a ${toString age} ans"
113+
```
114+
115+
## Gestion Conditionnelle et Héritage
116+
117+
### `if ... then ... else ...`
118+
119+
Les conditions dans Nix sont des expressions qui nécessitent à la fois une branche "vraie" et "fausse" :
120+
121+
```nix
122+
if condition
123+
then "c'est vrai"
124+
else "c'est faux"
125+
```
126+
127+
### Mot-clé `inherit`
128+
129+
Le mot-clé `inherit` permet d'hériter des variables ou des attributs d'un contexte parent :
130+
131+
```nix
132+
let
133+
name = "Alice";
134+
in {
135+
inherit name; # Equivalent à name = name;
136+
}
137+
```
138+
139+
### Les blocs `with`
140+
141+
`with` permet d'importer tous les attributs d'un ensemble dans le scope :
142+
143+
```nix
144+
let attrs = { a = 15; b = 2; };
145+
in with attrs; a + b
146+
# Résultat : 17
147+
```
148+
149+
## Importation et Chemins
150+
151+
Les fichiers Nix peuvent s'importer entre eux avec la fonction `import`. Le système de chemins Nix (`NIX_PATH`) permet d'accéder à des alias de chemins définis globalement.
152+
153+
```nix
154+
let pkgs = import <nixpkgs> {};
155+
in pkgs.hello
156+
```
157+
158+
## Bibliothèques Standard
159+
160+
Nix comprend plusieurs bibliothèques standard importantes :
161+
162+
1. **`builtins`** : Contient les fonctions de base du langage, comme `toString`, `fetchGit`, ou `derivation`.
163+
2. **`pkgs.lib`** : Inclut de nombreuses fonctions utilitaires pour manipuler des listes, ensembles d'attributs, et chaînes.
164+
3. **`pkgs`** : Représente l'ensemble des paquets disponibles dans Nixpkgs, incluant des fonctions de construction comme `writeText`.
165+
166+
## Les Dérivations
167+
168+
Une dérivation dans Nix décrit une action de construction. C'est un élément fondamental du modèle de gestion des paquets dans Nix.
169+
170+
```nix
171+
derivation {
172+
name = "hello";
173+
builder = "bash";
174+
args = [ "-c" "echo Hello, world!" ];
175+
}
176+
```
177+
178+
Les dérivations peuvent être générées via des fonctions de plus haut niveau comme `stdenv.mkDerivation`.
179+
180+
## Idiomes de Nix
181+
182+
### Lamba de Fichier
183+
184+
Il est courant d'utiliser une entête de fonction pour passer les dépendances dans les fichiers Nix, afin de permettre une modularité et une flexibilité accrues :
185+
186+
```nix
187+
{ pkgs ? import <nixpkgs> {} }:
188+
```
189+
190+
### `callPackage`
191+
192+
Nixpkgs utilise la fonction `callPackage` pour importer des fichiers avec leurs dépendances, en passant automatiquement les arguments requis :
193+
194+
```nix
195+
let my-package = pkgs.callPackage ./mon-paquet.nix {};
196+
in my-package
197+
```
198+
199+
### Overrides et Overlays
200+
201+
Nix permet d'écraser ou de modifier des paquets en utilisant des *overrides* ou des *overlays*, ce qui facilite l'adaptation et l'extension des paquets existants.
202+
203+
```nix
204+
somePackage.overrideAttrs (old: {
205+
configureFlags = old.configureFlags or [] ++ ["--nouveau-flag"];
206+
})
207+
```
208+
209+
## En Résumé
210+
211+
Le langage Nix, bien que simple, offre une approche puissante et flexible pour la gestion des paquets et des environnements logiciels. Avec ses concepts de pureté fonctionnelle, d'évaluation paresseuse, et d'isolation des dépendances, il permet de construire des systèmes reproductibles, robustes et adaptables. En maîtrisant ses idiomes et constructions, les utilisateurs de Nix peuvent créer et gérer des environnements complexes avec une grande facilité.

‎nixos/chap98.md

Lines changed: 7 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,12 @@
11
# Introduction aux Flakes dans Nix
22

3+
## Références
4+
5+
https://jameswillia.ms/posts/flake-line-by-line.html
6+
https://vtimofeenko.com/posts/practical-nix-flake-anatomy-a-guided-tour-of-flake.nix/
7+
https://serokell.io/blog/practical-nix-flakes
8+
9+
310
## Dans ce chapitre
411

512
- Introduction aux flakes dans Nix

0 commit comments

Comments
 (0)