[d/*] highlight as D

1 files changed, 20 insertions, 20 deletions

diff --git a/fr-fr/d-fr.html.markdown b/fr-fr/d-fr.html.markdown
index d0da8851..e593fdbd 100644
--- a/fr-fr/d-fr.html.markdown
+++ b/fr-fr/d-fr.html.markdown
@@ -8,7 +8,7 @@ translators:
 lang: fr-fr
 ---
 
-```c
+```d
 // Commençons par un classique
 module hello;
 
@@ -30,7 +30,7 @@ D est activement développé par de nombreuses personnes très intelligents, gui
 [Andrei Alexandrescu](https://fr.wikipedia.org/wiki/Andrei_Alexandrescu).
 Après cette petite introduction, jetons un coup d'oeil à quelques exemples.
 
-```c
+```d
 import std.stdio;
 
 void main() {
@@ -76,13 +76,13 @@ On peut définir de nouveaux types avec les mots-clés `struct`, `class`,
 `union` et `enum`. Ces types sont passés à la fonction par valeur (ils sont copiés)
 De plus, on peut utiliser les templates pour rendre toutes ces abstractions génériques.
 
-```c
+```d
 // Ici, 'T' est un paramètre de type. Il est similaire au <T> de C++/C#/Java.
 struct LinkedList(T) {
     T data = null;
 
-	// Utilisez '!' pour instancier un type paramétré.
-	// Encore une fois semblable à '<T>'
+    // Utilisez '!' pour instancier un type paramétré.
+    // Encore une fois semblable à '<T>'
     LinkedList!(T)* next;
 }
 
@@ -141,7 +141,7 @@ une méthode qui peut se comporter comme une lvalue. On peut donc utiliser
 la syntaxe des structures classiques (`struct.x = 7`) comme si il
 s'agissait de méthodes getter ou setter.
 
-```c
+```d
 // Considérons une classe paramétrée avec les types 'T' et 'U'
 class MyClass(T, U) {
     T _data;
@@ -153,9 +153,9 @@ class MyClass(T, U) {
     T _data;
     U _other;
 
-	// Les constructeurs s'appellent toujours 'this'.
+    // Les constructeurs s'appellent toujours 'this'.
     this(T t, U u) {
-		// Ceci va appeller les setters ci-dessous.
+        // Ceci va appeller les setters ci-dessous.
         data = t;
         other = u;
     }
@@ -183,18 +183,18 @@ class MyClass(T, U) {
 void main() {
     auto mc = new MyClass!(int, string)(7, "seven");
 
-	// Importer le module 'stdio' de la bibliothèque standard permet
-	// d'écrire dans la console (les imports peuvent être locaux à une portée)
+    // Importer le module 'stdio' de la bibliothèque standard permet
+    // d'écrire dans la console (les imports peuvent être locaux à une portée)
     import std.stdio;
 
-	// On appelle les getters pour obtenir les valeurs.
+    // On appelle les getters pour obtenir les valeurs.
     writefln("Earlier: data = %d, str = %s", mc.data, mc.other);
 
-	// On appelle les setter pour assigner de nouvelles valeurs.
+    // On appelle les setter pour assigner de nouvelles valeurs.
     mc.data = 8;
     mc.other = "eight";
 
-	// On appelle les setter pour obtenir les nouvelles valeurs.
+    // On appelle les setter pour obtenir les nouvelles valeurs.
     writefln("Later: data = %d, str = %s", mc.data, mc.other);
 }
 ```
@@ -214,17 +214,17 @@ de premier ordre, les fonctions `pures` et les données immuables.
 De plus, tout vos algorithmes fonctionels favoris (map, reduce, filter)
 sont disponibles dans le module `std.algorithm`.
 
-```c
+```d
 import std.algorithm : map, filter, reduce;
 import std.range : iota; // construit un intervalle excluant la dernière valeur.
 
 void main() {
-	// On veut un algorithme qui affiche la somme de la liste des carrés
-	// des entiers paires de 1 à 100. Un jeu d'enfant !
+    // On veut un algorithme qui affiche la somme de la liste des carrés
+    // des entiers paires de 1 à 100. Un jeu d'enfant !
 
-	// On se contente de passer des expressions lambda en paramètre à des templates.
-	// On peut fournir au template n'importe quelle fonction, mais dans notre
-	// cas, les lambdas sont pratiques.
+    // On se contente de passer des expressions lambda en paramètre à des templates.
+    // On peut fournir au template n'importe quelle fonction, mais dans notre
+    // cas, les lambdas sont pratiques.
     auto num = iota(1, 101).filter!(x => x % 2 == 0)
                            .map!(y => y ^^ 2)
                            .reduce!((a, b) => a + b);
@@ -244,7 +244,7 @@ est de type A, comme si c'était une méthode de A.
 J'aime le parallélisme. Vous aimez le parallélisme ? Bien sûr que vous aimez ça.
 Voyons comment on le fait en D !
 
-```c
+```d
 import std.stdio;
 import std.parallelism : parallel;
 import std.math : sqrt;