[nix/fr]: Add French translation (#4518)

1 files changed, 395 insertions, 0 deletions

diff --git a/fr-fr/nix-fr.html.markdown b/fr-fr/nix-fr.html.markdown
new file mode 100644
index 00000000..53fb87a8
--- /dev/null
+++ b/fr-fr/nix-fr.html.markdown
@@ -0,0 +1,395 @@
+---
+language: nix
+filename: learn.nix
+contributors:
+    - ["Chris Martin", "http://chris-martin.org/"]
+    - ["Rommel Martinez", "https://ebzzry.io"]
+    - ["Javier Candeira", "https://candeira.com/"]
+translators:
+    - ["Loïc Reynier", "https://github.com/loicreynier"]
+lang: fr-fr
+---
+
+Nix est un langage fonctionnel développé pour
+le gestionnaire de paquet [Nix](https://nixos.org/nix/) et
+[NixOS](https://nixos.org/).
+
+Les expressions Nix peuvent être évaluées avec
+[nix-instantiate](https://nixos.org/nix/manual/#sec-nix-instantiate)
+ou [`nix repl`](https://nixos.org/nix/manual/#ssec-relnotes-2.0).
+
+```nix
+with builtins; [
+
+  #  Commentaires
+  #=========================================
+
+  # Ceci est un commentaire en ligne.
+
+  /* Ceci est un commentaire
+     écrit sur plusieurs lignes. */
+
+
+  #  Booléens
+  #=========================================
+
+  (true && false)               # Et
+  #=> false
+
+  (true || false)               # Ou
+  #=> true
+
+  (if 3 < 4 then "a" else "b")  # Test logique
+  #=> "a"
+
+
+  #  Entiers et nombres flottants
+  #=========================================
+
+  # Il y a deux types de nombres : les entiers et les flottants.
+
+  1 0 42 (-3)       # Quelques exemples d'entiers
+
+  123.43 .27e13     # Quelques exemples de nombre flottants
+
+  # Les opérations conservent le type du nombre
+
+  (4 + 6 + 12 - 2)  # Addition
+  #=> 20
+  (4 - 2.5)
+  #=> 1.5
+
+  (7 / 2)           # Division
+  #=> 3
+  (7 / 2.0)
+  #=> 3.5
+
+
+  #  Chaînes de caractères
+  #=========================================
+
+  "Les chaînes de caractères littérales sont écrites entre guillements."
+
+  "
+    Les chaînes de caractères littérales
+    peuvent s'étendre sur
+    plusieurs lignes
+  "
+
+  ''
+    Ceci est ce qu'on appelle une
+    "chaîne de caractères littérale indentée".
+    Les espaces de début de lignes sont intelligemment supprimées.
+  ''
+
+  ''
+    a
+      b
+  ''
+  #=> "a\n  b"
+
+  ("ab" + "cd")   # Concaténation de chaînes de caractères
+  #=> "abcd"
+
+  # L'antiquotation vous permet d'intégrer des valeurs
+  # dans des chaînes de caracères.
+  ("Votre répertoire personnel est ${getEnv "HOME"}")
+  #=> "Votre répertoire personnel est /home/alice"
+
+
+  #  Chemins
+  #=========================================
+
+  # Nix a un type de variable primitif pour les chemins.
+  /tmp/tutorials/learn.nix
+
+  # Un chemin relatif est résolu en un chemin absolu
+  # au moment de l'évaluation.
+  tutorials/learn.nix
+  #=> /the-base-path/tutorials/learn.nix
+
+  # Un chemin doit toujours contenir au moins une barre oblique (slash).
+  # Un chemin relatif d'un fichier dans le répertoire courant
+  # a donc besoin du préfixe `./`
+  ./learn.nix
+  #=> /the-base-path/learn.nix
+
+  # L'opérateur `/` doit être entouré d'espaces afin d'être
+  # traité comme une division
+  7/2        # Ceci est un chemin
+  (7 / 2)    # Ceci est une division entière
+
+
+  #  Importations
+  #=========================================
+
+  # Un fichier nix contient une seule expression principale sans
+  # variable libre.
+  # Une expression importée s'évalue à la valeur du fichier importé.
+  (import /tmp/foo.nix)
+
+  # Les importations peuvent également être spécifiées par des chaînes
+  # de caractères.
+  (import "/tmp/foo.nix")
+
+  # Les chemins doivent être absolus. Cependant comme les chemins
+  # relatifs sont automatiquement résolus, ils peuvent être utilisés
+  # pour l'importation.
+  (import ./foo.nix)
+
+  # Attention, cela ne se produit pas avec les chaînes de caractères.
+  (import "./foo.nix")
+  #=> error: string ‘foo.nix’ doesn't represent an absolute path
+
+
+  #  Let
+  #=========================================
+
+  # Les blocs `let` permettent d'affecter des valeurs avec des variables.
+  (let x = "a"; in
+    x + x + x)
+  #=> "aaa"
+
+  # Les affectations peuvent se référer les unes aux autres, et leur ordre
+  # n'a pas d'importance.
+  (let y = x + "b";
+       x = "a"; in
+    y + "c")
+  #=> "abc"
+
+
+  # Les affectations d'un bloc fille écrasent les affections du bloc mère.
+  (let a = 1; in
+    let a = 2; in
+      a)
+  #=> 2
+
+
+  #  Fonctions
+  #=========================================
+
+  (n: n + 1)      # Fonction qui ajoute 1
+
+  ((n: n + 1) 5)  # Fonction précédente appliquée à 5
+  #=> 6
+
+  # Il n'y a pas de syntaxe pour nommer les fonctions,
+  # mais elles peuvent affectée à une variable par un bloc `let`
+  # comme toutes les autres valeurs.
+  (let succ = (n: n + 1); in succ 5)
+  #=> 6
+
+  # Une fonction a exactement un seul argument.
+  # Des fonctions à plusieurs arguments peuvent être construites
+  # par imbrificication de fonctions.
+  ((x: y: x + "-" + y) "a" "b")
+  #=> "a-b"
+
+  # Il est également possible d'avoir des arguments de fonction nommés.
+  # Nous verrons comment après avoir introduit les ensembles.
+
+
+  #  Listes
+  #=========================================
+
+  # Les listes sont indiquées par des crochets.
+
+  (length [1 2 3 "x"])
+  #=> 4
+
+  ([1 2 3] ++ [4 5])
+  #=> [1 2 3 4 5]
+
+  (concatLists [[1 2] [3 4] [5]])
+  #=> [1 2 3 4 5]
+
+  (head [1 2 3])
+  #=> 1
+  (tail [1 2 3])
+  #=> [2 3]
+
+  (elemAt ["a" "b" "c" "d"] 2)
+  #=> "c"
+
+  (elem 2 [1 2 3])
+  #=> true
+  (elem 5 [1 2 3])
+  #=> false
+
+  (filter (n: n < 3) [1 2 3 4])
+  #=> [ 1 2 ]
+
+
+  #  Ensembles
+  #=========================================
+
+  # Un ensemble, ou "set", est un dictionnaire non ordonné avec des clés
+  # en chaîne de caractères.
+  { foo = [1 2]; bar = "x"; }
+
+  # L'opérateur `.` extrait une valeur d'un ensemble.
+  { a = 1; b = 2; }.a
+  #=> 1
+
+  # L'opérateur `?` teste si la clé est présente dans l'ensemble.
+  ({ a = 1; b = 2; } ? a)
+  #=> true
+  ({ a = 1; b = 2; } ? c)
+  #=> false
+
+  # L'opérateur `//` fusionne deux ensembles.
+  ({ a = 1; } // { b = 2; })
+  #=> { a = 1; b = 2; }
+
+  # Les valeurs de droite écrasent les valeurs de gauche.
+  ({ a = 1; b = 2; } // { a = 3; c = 4; })
+  #=> { a = 3; b = 2; c = 4; }
+
+  # Le mot clé `rec` indique un ensemble récursif, ou "recursive set",
+  # dans lequel les attributs peuvent se référer les uns aux autres.
+  (let a = 1; in     { a = 2; b = a; }.b)
+  #=> 1
+  (let a = 1; in rec { a = 2; b = a; }.b)
+  #=> 2
+
+  # Les ensembles imbriqués peuvent être définis par morceaux.
+  {
+    a.b   = 1;
+    a.c.d = 2;
+    a.c.e = 3;
+  }.a.c
+  #=> { d = 2; e = 3; }
+
+  # Les ensembles sont immuables, il est donc impossible de rédéfinir
+  # un attribut :
+  {
+    a = { b = 1; };
+    a.b = 2;
+  }
+  #=> attribute 'a.b' at (string):3:5 already defined at (string):2:11
+
+  # Cependant un attribut d'un attribut de l'ensemble peut également
+  # être défini par morceaux même si l'attribut père a été directement
+  # défini.
+  {
+    a = { b = 1; };
+    a.c = 2;
+  }
+  #=> { a = { b = 1; c = 2; }; }
+
+
+  #  With
+  #=========================================
+
+  # Le corps d'un bloc `with` est évalué avec
+  # les mappings d'un ensemble liés à des variables.
+  (with { a = 1; b = 2; };
+    a + b)
+  # => 3
+
+  # Les affectations d'un bloc fille écrasent les affections du bloc mère.
+  (with { a = 1; b = 2; };
+    (with { a = 5; };
+      a + b))
+  #=> 7
+
+  # La première ligne du tutoriel commence par `with builtins;`
+  # car `builtins` est un ensmble qui contient toutes les fonctions
+  # de base (`length`, `head`, `tail`, `filter`, etc.). Cela permet
+  # de ne pas avoir à écrire `builtins.length` au lieu de simplement
+  # `length` par exemple.
+
+
+  #  Modèles d'ensemble
+  #=========================================
+
+  # Les ensembles sont utiles pour passer plusieurs valeurs
+  # à une fonction.
+  (args: args.x + "-" + args.y) { x = "a"; y = "b"; }
+  #=> "a-b"
+
+  # On peut l'écrire plus clairement en utilisant des modèles d'ensemble,
+  # ou "set patterns".
+  ({x, y}: x + "-" + y) { x = "a"; y = "b"; }
+  #=> "a-b"
+
+  # Par défaut, le modèle échoue si l'ensemble contient des clés
+  # supplémentaires.
+  ({x, y}: x + "-" + y) { x = "a"; y = "b"; z = "c"; }
+  #=> error: anonymous function called with unexpected argument ‘z’
+
+  # L'ajout de `, ...` permet d'ignorer les clés supplémentaires.
+  ({x, y, ...}: x + "-" + y) { x = "a"; y = "b"; z = "c"; }
+  #=> "a-b"
+
+
+  #  Erreurs
+  #=========================================
+
+  # `throw` provoque l'abandon de l'évaluation avec un message d'erreur.
+  (2 + (throw "foo"))
+  #=> error: foo
+
+  # `tryEval` permet de capturer les erreurs.
+  (tryEval 42)
+  #=> { success = true; value = 42; }
+  (tryEval (2 + (throw "foo")))
+  #=> { success = false; value = false; }
+
+  # `abort` est comme `throw`, mais l'erreur est alors fatale :
+  # elle ne peut pas être capturée.
+  (tryEval (abort "foo"))
+  #=> error: evaluation aborted with the following error message: ‘foo’
+
+  # `assert` s'évalue à la valeur donnée si le test est vrai;
+  # sinon il lève une exception capturable.
+  (assert 1 < 2; 42)
+  #=> 42
+  (assert 1 > 2; 42)
+  #=> error: assertion failed at (string):1:1
+  (tryEval (assert 1 > 2; 42))
+  #=> { success = false; value = false; }
+
+
+  #  Impureté
+  #=========================================
+
+
+  # La répétabilité des constructions étant critique pour le
+  # gestionnaire de paquets Nix, la pureté fonctionnelle est
+  # mise en avant dans le langage Nix. Cependant, il existe des
+  # impuretés.
+
+  # Vous pouvez vous référer aux variables d'environnement.
+  (getEnv "HOME")
+  #=> "/home/alice"
+
+
+  # La fonction `trace` est utilisée pour le débogage.
+  # Elle affiche le premier argument dans `stderr` et
+  # évalue le second argument.
+  (trace 1 2)
+  #=> trace: 1
+  #=> 2
+
+  # Vous pouvez écrire des fichiers dans le magasin Nix (Nix store).
+  # Bien qu'impur, c'est assez sûr car le nom du fichier est dérivé
+  # du hachage de  son contenu. On peut lire des fichiers depuis n'importe où.
+  # Dans cet exemple, on écrit un fichier dans le magasin, puis on le relit.
+  (let filename = toFile "foo.txt" "hello!"; in
+    [filename (builtins.readFile filename)])
+  #=> [ "/nix/store/ayh05aay2anx135prqp0cy34h891247x-foo.txt" "hello!" ]
+
+  # Il est également possible de télécharger des fichiers dans le magasin Nix.
+  (fetchurl "https://example.com/package-1.2.3.tgz")
+  #=> "/nix/store/2drvlh8r57f19s9il42zg89rdr33m2rm-package-1.2.3.tgz"
+
+]
+```
+
+### Pour en savoir plus (anglais)
+
+- [Nix Manual - Nix expression language](https://nixos.org/nix/manual/#ch-expression-language)
+- [James Fisher - Nix by example - Part 1: The Nix expression language](https://medium.com/@MrJamesFisher/nix-by-example-a0063a1a4c55)
+- [Susan Potter - Nix Cookbook - Nix By Example](https://ops.functionalalgebra.com/nix-by-example/)
+- [Rommel Martinez - A Gentle Introduction to the Nix Family](https://web.archive.org/web/20210121042658/https://ebzzry.io/en/nix/#nix)