Le langage Nix : types, fonctions, attrsets et expressions

Le langage Nix est un langage fonctionnel pur conçu pour décrire des paquets et des configurations de manière reproductible. Tout y est expression : un nombre, une fonction, un fichier de configuration — chaque élément retourne une valeur, rien ne produit d’effet de bord. Ce guide vous fait découvrir chaque concept fondamental en le testant immédiatement dans le REPL ou avec nix eval.

Ce que vous allez apprendre

• Manipuler les 7 types primitifs de Nix (entiers, flottants, chaînes, booléens, null, chemins, fonctions)
• Structurer des données avec les attribute sets (attrsets) et les listes
• Définir et appeler des fonctions (simples, curryfiées, à arguments nommés)
• Utiliser let...in, with, inherit et if-then-else
• Transformer des données avec les builtins (map, filter, attrNames…)
• Écrire des expressions complètes prêtes pour shell.nix ou flake.nix

Dans quel contexte ?

Le langage Nix est le socle de tout l’écosystème : chaque paquet est décrit par une expression Nix, chaque shell.nix, chaque flake.nix, chaque module NixOS est du code Nix. Comprendre le langage vous permet de :

• lire et modifier les fichiers shell.nix ou flake.nix de vos projets,
• écrire vos propres dérivations pour empaqueter des logiciels,
• déboguer un environnement de développement qui ne se comporte pas comme prévu,
• comprendre les exemples de la documentation nixpkgs et NixOS,
• personnaliser une configuration NixOS module par module.

Le REPL : votre terrain d’expérimentation

Le REPL (Read-Eval-Print Loop) est un terminal interactif pour tester des expressions Nix. Lancez-le avec :

nix repl --expr '{}'

Tapez une expression, Nix l’évalue et affiche le résultat. Tapez :q pour quitter.

Vous pouvez aussi évaluer des expressions ponctuelles directement dans le terminal avec :

nix eval --expr '1 + 2'

Résultat

3

Tous les exemples de ce guide sont testables avec l’une ou l’autre méthode.

Types primitifs

Nix possède 7 types de base. Vous pouvez vérifier le type de n’importe quelle valeur avec builtins.typeOf :

Entiers et flottants

nix eval --expr '1 + 2'

Résultat

3

nix eval --expr '7 / 2'

Résultat

3

La division entre entiers est entière (pas d’arrondi, troncature). Pour obtenir un résultat décimal :

nix eval --expr '7.0 / 2.0'

Résultat

3.5

nix eval --expr 'builtins.typeOf 42'

Résultat

"int"

Chaînes de caractères

Les chaînes sont délimitées par des guillemets doubles :

nix eval --expr '"hello" + " world"'

Résultat

"hello world"

L’opérateur + concatène les chaînes (et additionne les nombres — Nix distingue par le type des opérandes).

Interpolation avec ${} :

nix eval --expr 'let name = "Nix"; in "Hello ${name}"'

Résultat

"Hello Nix"

Pour interpoler un nombre, convertissez avec toString :

let port = 8080; in "Port: ${toString port}"
# "Port: 8080"

Chaînes multilignes — délimitées par '' (deux apostrophes simples) :

''
  Première ligne
  Deuxième ligne
''

L’indentation minimale commune est automatiquement supprimée.

Booléens

nix eval --expr 'true && false'

Résultat

false

nix eval --expr 'true || false'

Résultat

true

Opérateurs de comparaison : ==, !=, <, >, <=, >=.

nix eval --expr '3 > 2'

Résultat

true

Null et chemins

null       # type "null" — absence de valeur
/tmp       # type "path" — chemin absolu
./.        # type "path" — chemin relatif

Note

Les chemins sont un type à part entière en Nix (pas des chaînes). Un chemin relatif comme ./config.nix est résolu par rapport au fichier qui le contient. C’est ce qui rend import ./config.nix fiable.

Récapitulatif des types

Type	Exemples	builtins.typeOf
Entier	42, -1, 0	"int"
Flottant	3.14, 7.0	"float"
Chaîne	"hello", ''multi''	"string"
Booléen	true, false	"bool"
Null	null	"null"
Chemin	/tmp, ./file.nix	"path"
Fonction	x: x + 1	"lambda"

Glissez pour voir

Listes

Les listes sont des collections ordonnées, délimitées par des crochets et séparées par des espaces (pas de virgules) :

[ 1 2 3 ]
[ "hello" true 42 ]  # types mixtes autorisés

Opérations sur les listes

nix eval --expr 'builtins.length [ 1 2 3 ]'

Résultat

3

nix eval --expr 'builtins.head [ 10 20 30 ]'

Résultat

10

nix eval --expr 'builtins.tail [ 10 20 30 ]'

Résultat

[ 20 30 ]

nix eval --expr '[ 1 2 ] ++ [ 3 4 ]'

Résultat

[ 1 2 3 4 ]

L’opérateur ++ concatène deux listes. builtins.elem teste l’appartenance :

nix eval --expr 'builtins.elem 3 [ 1 2 3 ]'

Résultat

true

Attribute sets (attrsets)

L’attribute set est la structure de données fondamentale de Nix — un dictionnaire clé-valeur. Chaque attribut se termine par un ; :

{
  name = "Alice";
  age = 30;
  active = true;
}

Accès et manipulation

nix eval --expr '{ a = 1; b = 2; }.a'

Résultat

1

Fusion avec //

L’opérateur // fusionne deux attrsets. Les clés du côté droit écrasent celles du côté gauche :

nix eval --expr '{ a = 1; b = 2; } // { b = 99; c = 3; }'

Résultat

{ a = 1; b = 99; c = 3; }

Introspection

nix eval --expr 'builtins.attrNames { z = 1; a = 2; m = 3; }'

Résultat

[ "a" "m" "z" ]

Les noms sont retournés triés alphabétiquement.

nix eval --expr 'builtins.attrValues { a = 10; b = 20; }'

Résultat

[ 10 20 ]

Test d’existence avec ?

nix eval --expr '{ a = 1; } ? a'

Résultat

true

nix eval --expr '{ a = 1; } ? b'

Résultat

false

Combiné avec or pour une valeur par défaut :

let config = { port = 8080; };
in config.host or "localhost"
# "localhost"

Attrsets récursifs avec rec

Un attrset normal ne peut pas référencer ses propres attributs. Avec rec, il le peut :

rec {
  name = "hello";
  fullName = "${name}-world";  # utilise 'name' du même attrset
}
# { name = "hello"; fullName = "hello-world"; }

Attention

Utilisez rec avec parcimonie. Il peut créer des dépendances circulaires difficiles à déboguer. Préférez let...in quand c’est possible.

Fonctions

En Nix, les fonctions sont des valeurs comme les autres. La syntaxe est argument: corps — le : sépare l’argument du corps.

Fonctions simples

nix eval --expr '(x: x * 2) 5'

Résultat

10

La fonction x: x * 2 prend un argument x et retourne x * 2. On l’appelle en lui passant 5 juste après.

Fonctions curryfiées (plusieurs arguments)

Nix ne supporte qu’un argument par fonction. Pour plusieurs arguments, on chaîne les fonctions :

nix eval --expr '(a: b: a + b) 3 4'

Résultat

7

a: b: a + b est en fait a: (b: a + b) — une fonction qui retourne une fonction.

Fonctions à arguments nommés (pattern matching)

C’est la forme la plus courante dans les fichiers Nix. L’argument est un attrset destructuré :

nix eval --expr '({ name, age }: "${name} a ${toString age} ans") { name = "Alice"; age = 30; }'

Résultat

"Alice a 30 ans"

Valeurs par défaut avec ?

{ name, port ? 8080 }:
  "Server ${name} on port ${toString port}"

Si port n’est pas fourni, la valeur 8080 est utilisée.

Arguments supplémentaires avec ...

{ name, port ? 8080, ... }:
  "Server ${name}"

Le ... autorise l’appelant à passer des attributs supplémentaires sans erreur.

Astuce

La syntaxe { pkgs ? import <nixpkgs> {} }: que vous voyez dans presque tous les fichiers shell.nix est exactement cette forme : une fonction qui attend un attrset avec un attribut pkgs ayant une valeur par défaut.

Variables locales : let...in

Le bloc let...in crée des variables locales immuables :

nix eval --expr 'let x = 5; y = 3; in x + y'

Résultat

8

Les variables peuvent se référencer mutuellement :

let
  base = 10;
  double = base * 2;
  triple = base * 3;
in
  double + triple
# 50

Note

Les variables Nix sont immuables. Une fois définies, elles ne changent jamais. Il n’y a pas d’affectation x = x + 1. C’est une garantie de reproductibilité.

with — importer un scope

Le mot-clé with importe tous les attributs d’un attrset dans le scope courant :

nix eval --expr 'let s = { a = 1; b = 2; }; in with s; a + b'

Résultat

3

Usage typique — éviter de répéter pkgs. :

# Sans with
packages = [ pkgs.git pkgs.vim pkgs.ripgrep ];

# Avec with
packages = with pkgs; [ git vim ripgrep ];

inherit — raccourci d’assignation

inherit copie des variables du scope englobant dans un attrset :

nix eval --expr 'let x = 1; y = 2; in { inherit x y; }'

Résultat

{ x = 1; y = 2; }

inherit x y; est strictement équivalent à x = x; y = y;.

On peut aussi hériter depuis un autre attrset :

let config = { port = 8080; host = "localhost"; };
in { inherit (config) port host; }
# { port = 8080; host = "localhost"; }

Conditionnels : if-then-else

En Nix, if est une expression qui retourne toujours une valeur :

nix eval --expr 'if 3 > 2 then "oui" else "non"'

Résultat

"oui"

Le else est obligatoire — toute expression doit retourner une valeur.

Usage typique — paquets conditionnels :

let
  debugMode = true;
  debugTools = if debugMode then [ pkgs.htop pkgs.ncdu ] else [];
in
  basePackages ++ debugTools

import — charger un fichier Nix

import charge et évalue un fichier .nix :

# Si config.nix contient { port = 8080; host = "localhost"; }
let config = import ./config.nix;
in config.port
# 8080

Si le fichier importé est une fonction, il faut l’appeler avec ses arguments :

# Si tools.nix contient { pkgs }: [ pkgs.git pkgs.vim ]
let tools = import ./tools.nix { inherit pkgs; };
in tools

<nixpkgs> est un chemin spécial résolu via les channels ou le registre. import <nixpkgs> {} retourne l’attrset gigantesque contenant tous les paquets.

Builtins : fonctions intégrées

Nix fournit des fonctions intégrées dans l’objet builtins. Voici les plus utiles :

map — transformer une liste

nix eval --expr 'map (x: x * 2) [ 1 2 3 4 ]'

Résultat

[ 2 4 6 8 ]

builtins.filter — filtrer une liste

nix eval --expr 'builtins.filter (x: x > 2) [ 1 2 3 4 5 ]'

Résultat

[ 3 4 5 ]

Autres builtins utiles

Builtin	Usage	Exemple
builtins.length	Taille d’une liste	builtins.length [ 1 2 3 ] → 3
builtins.head	Premier élément	builtins.head [ 10 20 ] → 10
builtins.tail	Liste sans le premier	builtins.tail [ 10 20 30 ] → [ 20 30 ]
builtins.elem	Appartenance	builtins.elem 3 [ 1 2 3 ] → true
builtins.attrNames	Clés d’un attrset	builtins.attrNames { a = 1; } → [ "a" ]
builtins.attrValues	Valeurs d’un attrset	builtins.attrValues { a = 1; } → [ 1 ]
builtins.hasAttr	Test d’attribut	builtins.hasAttr "a" { a = 1; } → true
toString	Conversion en chaîne	toString 42 → "42"
builtins.typeOf	Type d’une valeur	builtins.typeOf 42 → "int"

Glissez pour voir

Mettre tout ensemble : anatomie d’un shell.nix

Voici comment les concepts se combinent dans un fichier shell.nix typique :

shell.nix

{ pkgs ? import <nixpkgs> {} }:    # ← fonction à argument nommé + défaut

let                                 # ← variables locales
  projectName = "mon-api";

  pythonEnv = pkgs.python312.withPackages (ps: [  # ← lambda
    ps.requests
    ps.flask
  ]);

  debugMode = true;
  debugTools = if debugMode         # ← conditionnel
    then [ pkgs.htop pkgs.ncdu ]
    else [];
in
pkgs.mkShell {                      # ← attrset passé à une fonction
  name = "${projectName}-dev";      # ← interpolation

  packages = with pkgs; [           # ← with
    pythonEnv
    git
    vim
  ] ++ debugTools;                  # ← concaténation de listes

  PROJECT_NAME = projectName;       # ← variable d'environnement
}

Chaque ligne utilise un concept que vous venez d’apprendre. Les guides suivants approfondissent les environnements de développement et la modularisation de ces fichiers.

Récapitulatif des concepts

Concept	Syntaxe	Description
Types	42, "hello", true, null	7 types primitifs, tout est expression
Listes	[ 1 2 3 ]	Collections ordonnées, séparées par des espaces
Attrsets	{ clé = valeur; }	Dictionnaires, structure fondamentale de Nix
Fonctions	arg: corps	Valeurs de première classe, un seul argument
Args nommés	{ a, b ? 0 }: ...	Destructuration d’attrset avec défauts optionnels
let … in	let x = 1; in x	Variables locales immuables
with	with pkgs; [ git ]	Importe les attributs dans le scope
inherit	{ inherit x; }	Raccourci pour x = x
if-then-else	if c then a else b	Expression conditionnelle (else obligatoire)
Opérateur //	a // b	Fusion d’attrsets (droite écrase gauche)
Opérateur ++	[ 1 ] ++ [ 2 ]	Concaténation de listes
import	import ./file.nix	Charge et évalue un fichier
Interpolation	"Hello ${name}"	Insertion d’expressions dans les chaînes

Glissez pour voir

À retenir

• Tout est expression en Nix : il n’y a pas d’instructions, chaque élément retourne une valeur.
• Les attrsets ({ clé = valeur; }) sont la structure universelle — les paquets, les configurations, les modules sont tous des attrsets.
• Les fonctions sont omniprésentes : chaque fichier .nix est généralement une fonction qui attend pkgs ou d’autres arguments.
• Les variables sont immuables : une fois définies dans un let, elles ne changent plus.
• with, inherit et // sont des raccourcis syntaxiques qui rendent le code plus lisible — ils ne sont pas obligatoires mais très courants.
• Le REPL (nix repl) et nix eval --expr sont vos meilleurs alliés pour expérimenter.

Prochaines étapes

Environnements de développement Appliquez le langage Nix pour créer des shells reproductibles par projet.

Import, factorisation et pinning Modularisez vos fichiers Nix et figez les versions pour la reproductibilité.

Les flakes Le workflow moderne avec verrouillage automatique des dépendances.

×

📖 Voir la documentation →