[d/*] highlight as D

d.html.markdown

@@ -3,7 +3,6 @@ language: D
 filename: learnd.d
 contributors:
     - ["Nick Papanastasiou", "www.nickpapanastasiou.github.io"]
-
 ---
 
 ```d

de-de/d-de.html.markdown

@@ -39,7 +39,7 @@ void main() {
     }
 
     auto n = 1; // auto um den Typ vom Compiler bestimmen zu lassen
-    
+
     // Zahlenliterale können _ verwenden für lesbarkeit
     while(n < 10_000) {
         n += n;
@@ -82,7 +82,7 @@ struct LinkedList(T) {
 
 class BinTree(T) {
     T data = null;
-    
+
     // Wenn es nur einen T Parameter gibt, können die Klammern um ihn weggelassen werden
     BinTree!T left;
     BinTree!T right;
@@ -147,13 +147,13 @@ class MyClass(T, U) {
 class MyClass(T, U) {
     T _data;
     U _other;
-    
+
     // Konstruktoren heißen immer `this`
     this(T t, U u) {
         data = t;
         other = u;
     }
-    
+
     // getters
     @property T data() {
         return _data;
@@ -163,8 +163,8 @@ class MyClass(T, U) {
         return _other;
     }
 
-    // setters    
-	// @property kann genauso gut am ende der Methodensignatur stehen
+    // setters
+    // @property kann genauso gut am ende der Methodensignatur stehen
     void data(T t) @property {
         _data = t;
     }
@@ -180,7 +180,7 @@ void main() {
 
     mc.data = 7;
     mc.other = "seven";
-    
+
     writeln(mc.data);
     writeln(mc.other);
 }
@@ -208,10 +208,10 @@ import std.range : iota; // builds an end-exclusive range
 void main() {
     // Wir wollen die Summe aller Quadratzahlen zwischen
     // 1 und 100 ausgeben. Nichts leichter als das!
- 
+
     // Einfach eine Lambda-Funktion als Template Parameter übergeben
     // Es ist genau so gut möglich eine normale Funktion hier zu übergeben
-	// Lambdas bieten sich hier aber an.
+    // Lambdas bieten sich hier aber an.
     auto num = iota(1, 101).filter!(x => x % 2 == 0)
                            .map!(y => y ^^ 2)
                            .reduce!((a, b) => a + b);
@@ -225,7 +225,7 @@ um num zu berechnen?
 Das war möglich durch die Uniform Function Call Syntax.
 Mit UFCS können wir auswählen, ob wir eine Funktion als Methode oder
 als freie Funktion aufrufen. Walters artikel dazu findet ihr
-[hier.](http://www.drdobbs.com/cpp/uniform-function-call-syntax/232700394) 
+[hier.](http://www.drdobbs.com/cpp/uniform-function-call-syntax/232700394)
 Kurzgesagt kann man Funktionen, deren erster Parameter vom typ A ist, als
 Methode auf A anwenden.
 

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;

hi-in/d.html.markdown

@@ -6,7 +6,7 @@ contributors:
 lang: hi-in
 ---
 
-```c
+```d
 //क्या आ रहा है पता है ...
 module hello;
 
@@ -27,7 +27,7 @@ D सक्रिय रूप से सुपर स्मार्ट लो
 [आंद्रेई Alexandrescu](https://en.wikipedia.org/wiki/Andrei_Alexandrescu)।
 जिस तरह की है कि सभी के साथ बाहर, चलो कुछ उदाहरणों पर गौर करते हैं!
 
-```c
+```d
 import std.stdio;
 
 void main() {
@@ -70,7 +70,7 @@ void main() {
 मूल्य से कार्य करने के लिए पारित कर रहे हैं (यानी नकल) और वर्गों के संदर्भ द्वारा पारित कर रहे हैं। इसके अलावा,
 हम प्रकारों और मानों दोनों पर करने के लिए टेम्पलेट का उपयोग कर सकते हैं!
 
-```c
+```d
 // इधर, 'T' एक प्रकार पैरामीटर है। लगता है कि '<+T>' C++ / C/ Java से।
 struct LinkedList(T) {
     T data = null;
@@ -132,7 +132,7 @@ Classes की बात हो रही है , एक दूसरे के
 के शब्दों के साथ पॉड संरचनाओं की वाक्य रचना (`structure.x = 7`) है
 मनुष्य और सेटर तरीकों (`object.setX(7)`) !
 
-```c
+```d
 // Consider a class parameterized on types 'T' & 'U'.
 class MyClass(T, U) {
     T _data;
@@ -206,7 +206,7 @@ void main() {
 कार्यात्मक एल्गोरिदम ( नक्शा, फिल्टर , कम करने और मित्र हो सकते हैं)
 अद्भुत `std.algorithm` मॉड्यूल में पाया!
 
-```c
+```d
 import std.algorithm : map, filter, reduce;
 import std.range : iota; // builds an end-exclusive range
 
@@ -234,7 +234,7 @@ UFCS के साथ, हम एक विधि के रूप में ए
 
 मैं समानता चाहते । समानता की तरह कोई और? ज़रूर तुम करना। चलो कुछ करते हैं!
 
-```c
+```d
 import std.stdio;
 import std.parallelism : parallel;
 import std.math : sqrt;

ru-ru/d-ru.html.markdown

@@ -12,7 +12,7 @@ D - современный компилируемый язык общего на
 который сочетает удобство, продуманный дизайн и высокую производительность.
 D - это С++, сделанный правильно.
 
-```c
+```d
 // Welcome to D! Это однострочный комментарий
 
 /* многострочный