From be9e47d810e087d2cd123b99495455a0f3607ace Mon Sep 17 00:00:00 2001
From: Jonas Friedemann Grote <jonas.grote@vico-research.com>
Date: Fri, 8 Sep 2017 12:38:30 +0200
Subject: Remove trailing spaces.

---
 de-de/scala-de.html.markdown | 458 +++++++++++++++++++++----------------------
 1 file changed, 229 insertions(+), 229 deletions(-)

(limited to 'de-de')

diff --git a/de-de/scala-de.html.markdown b/de-de/scala-de.html.markdown
index ddadcd8e..ddce3f6b 100644
--- a/de-de/scala-de.html.markdown
+++ b/de-de/scala-de.html.markdown
@@ -12,12 +12,12 @@ filename: learnscala-de.scala
 lang: de-de
 ---
 
-Scala ist eine funktionale und objektorientierte Programmiersprache  
-für die Java Virtual Machine (JVM), um allgemeine Programmieraufgaben  
-zu erledigen. Scala hat einen akademischen Hintergrund und wurde an  
+Scala ist eine funktionale und objektorientierte Programmiersprache
+für die Java Virtual Machine (JVM), um allgemeine Programmieraufgaben
+zu erledigen. Scala hat einen akademischen Hintergrund und wurde an
 der EPFL (Lausanne / Schweiz) unter der Leitung von Martin Odersky entwickelt.
 
-```scala 
+```scala
 /*
 Scala Umgebung einrichten:
 
@@ -28,9 +28,9 @@ Scala Umgebung einrichten:
 
 scala>
 
-Die REPL (Read-Eval-Print Loop) ist der interaktive Scala Interpreter.  
-Hier kann man jeden Scala Ausdruck verwenden und das Ergebnis wird direkt  
-ausgegeben.  
+Die REPL (Read-Eval-Print Loop) ist der interaktive Scala Interpreter.
+Hier kann man jeden Scala Ausdruck verwenden und das Ergebnis wird direkt
+ausgegeben.
 Als nächstes beschäftigen wir uns mit ein paar Scala Basics.
 */
 
@@ -42,25 +42,25 @@ Als nächstes beschäftigen wir uns mit ein paar Scala Basics.
 // Einzeilige Kommentare beginnen mit zwei Slashes
 
 /*
-  Mehrzeilige Kommentare, starten 
+  Mehrzeilige Kommentare, starten
   mit einem Slash-Stern und enden mit einem Stern-Slash
 */
 
-// Einen Wert, und eine zusätzliche neue Zeile ausgeben  
+// Einen Wert, und eine zusätzliche neue Zeile ausgeben
 
 println("Hello world!")
 println(10)
 
 
-// Einen Wert, ohne eine zusätzliche neue Zeile ausgeben  
+// Einen Wert, ohne eine zusätzliche neue Zeile ausgeben
 
 print("Hello world")
 
 /*
-  Variablen werden entweder mit var oder val deklariert.  
-  Deklarationen mit val sind immutable, also unveränderlich  
-  Deklarationen mit var sind mutable, also veränderlich  
-  Immutability ist gut.  
+  Variablen werden entweder mit var oder val deklariert.
+  Deklarationen mit val sind immutable, also unveränderlich
+  Deklarationen mit var sind mutable, also veränderlich
+  Immutability ist gut.
 */
 val x = 10 // x ist 10
 x = 20     // error: reassignment to val
@@ -68,29 +68,29 @@ var y = 10
 y = 20     // y ist jetzt 20
 
 /*
-Scala ist eine statisch getypte Sprache, auch wenn wir in dem o.g. Beispiel  
-keine Typen an x und y geschrieben haben.  
-In Scala ist etwas eingebaut, was sich Type Inference nennt. Das heißt das der  
-Scala Compiler in den meisten Fällen erraten kann, von welchen Typ eine Variable ist,  
-so dass der Typ nicht jedes mal angegeben werden muss.  
-Einen Typ gibt man bei einer Variablendeklaration wie folgt an:  
+Scala ist eine statisch getypte Sprache, auch wenn wir in dem o.g. Beispiel
+keine Typen an x und y geschrieben haben.
+In Scala ist etwas eingebaut, was sich Type Inference nennt. Das heißt das der
+Scala Compiler in den meisten Fällen erraten kann, von welchen Typ eine Variable ist,
+so dass der Typ nicht jedes mal angegeben werden muss.
+Einen Typ gibt man bei einer Variablendeklaration wie folgt an:
 */
 val z: Int = 10
 val a: Double = 1.0
 
 
-// Bei automatischer Umwandlung von Int auf Double wird aus 10 eine 10.0  
+// Bei automatischer Umwandlung von Int auf Double wird aus 10 eine 10.0
 
 val b: Double = 10
 
 
-// Boolean Werte  
+// Boolean Werte
 
 true
 false
 
 
-// Boolean Operationen  
+// Boolean Operationen
 
 !true         // false
 !false        // true
@@ -98,7 +98,7 @@ true == false // false
 10 > 5        // true
 
 
-// Mathematische Operationen sind wie gewohnt  
+// Mathematische Operationen sind wie gewohnt
 
 1 + 1   // 2
 2 - 1   // 1
@@ -108,44 +108,44 @@ true == false // false
 6.0 / 4 // 1.5
 
 
-// Die Auswertung eines Ausdrucks in der REPL gibt den Typ  
-// und das Ergebnis zurück.  
+// Die Auswertung eines Ausdrucks in der REPL gibt den Typ
+// und das Ergebnis zurück.
 
   scala> 1 + 7
   res29: Int = 8
 
 /*
-Das bedeutet, dass das Resultat der Auswertung von 1 + 7 ein Objekt  
-von Typ Int ist und einen Wert 0 hat.  
-"res29" ist ein sequentiell generierter name, um das Ergebnis des  
-Ausdrucks zu speichern. Dieser Wert kann bei Dir anders sein...  
+Das bedeutet, dass das Resultat der Auswertung von 1 + 7 ein Objekt
+von Typ Int ist und einen Wert 0 hat.
+"res29" ist ein sequentiell generierter name, um das Ergebnis des
+Ausdrucks zu speichern. Dieser Wert kann bei Dir anders sein...
 */
 
-"Scala strings werden in doppelten Anführungszeichen eingeschlossen"  
-'a' // A Scala Char  
-// 'Einzeln ge-quotete strings gibt es nicht!' <= This causes an error  
-  
-// Für Strings gibt es die üblichen Java Methoden  
+"Scala strings werden in doppelten Anführungszeichen eingeschlossen"
+'a' // A Scala Char
+// 'Einzeln ge-quotete strings gibt es nicht!' <= This causes an error
+
+// Für Strings gibt es die üblichen Java Methoden
 
 "hello world".length
 "hello world".substring(2, 6)
 "hello world".replace("C", "3")
 
 
-// Zusätzlich gibt es noch extra Scala Methoden  
-// siehe: scala.collection.immutable.StringOps  
+// Zusätzlich gibt es noch extra Scala Methoden
+// siehe: scala.collection.immutable.StringOps
 
 "hello world".take(5)
 "hello world".drop(5)
 
 
-// String interpolation: prefix "s"  
+// String interpolation: prefix "s"
 
 val n = 45
 s"We have $n apples" // => "We have 45 apples"
 
 
-// Ausdrücke im Innern von interpolierten Strings gibt es auch  
+// Ausdrücke im Innern von interpolierten Strings gibt es auch
 
 val a = Array(11, 9, 6)
 val n = 100
@@ -154,42 +154,42 @@ s"We have double the amount of ${n / 2.0} in apples." // => "We have double the
 s"Power of 2: ${math.pow(2, 2)}"                      // => "Power of 2: 4"
 
 
-// Formatierung der interpolierten Strings mit dem prefix "f"  
+// Formatierung der interpolierten Strings mit dem prefix "f"
 
 f"Power of 5: ${math.pow(5, 2)}%1.0f"         // "Power of 5: 25"
 f"Square root of 122: ${math.sqrt(122)}%1.4f" // "Square root of 122: 11.0454"
 
 
-// Raw Strings, ignorieren Sonderzeichen.  
+// Raw Strings, ignorieren Sonderzeichen.
 
 raw"New line feed: \n. Carriage return: \r." // => "New line feed: \n. Carriage return: \r."
 
 
-// Manche Zeichen müssen "escaped" werden, z.B.   
-// ein doppeltes Anführungszeichen in innern eines Strings.  
+// Manche Zeichen müssen "escaped" werden, z.B.
+// ein doppeltes Anführungszeichen in innern eines Strings.
 
 "They stood outside the \"Rose and Crown\"" // => "They stood outside the "Rose and Crown""
 
 
-// Dreifache Anführungszeichen erlauben es, dass ein String über mehrere Zeilen geht  
-// und Anführungszeichen enthalten kann.  
+// Dreifache Anführungszeichen erlauben es, dass ein String über mehrere Zeilen geht
+// und Anführungszeichen enthalten kann.
 
 val html = """<form id="daform">
                 <p>Press belo', Joe</p>
                 <input type="submit">
               </form>"""
 
-  
+
 /////////////////////////////////////////////////
 // 2. Funktionen
 /////////////////////////////////////////////////
 
-// Funktionen werden so definiert  
-//  
-//   def functionName(args...): ReturnType = { body... }  
-//  
-// Beachte: Es gibt kein return Schlüsselwort. In Scala ist der letzte Ausdruck  
-// in einer Funktion der Rückgabewert.  
+// Funktionen werden so definiert
+//
+//   def functionName(args...): ReturnType = { body... }
+//
+// Beachte: Es gibt kein return Schlüsselwort. In Scala ist der letzte Ausdruck
+// in einer Funktion der Rückgabewert.
 
 def sumOfSquares(x: Int, y: Int): Int = {
   val x2 = x * x
@@ -198,75 +198,75 @@ def sumOfSquares(x: Int, y: Int): Int = {
 }
 
 
-// Die geschweiften Klammern können weggelassen werden, wenn  
-// die Funktion nur aus einem einzigen Ausdruck besteht:  
+// Die geschweiften Klammern können weggelassen werden, wenn
+// die Funktion nur aus einem einzigen Ausdruck besteht:
 
 def sumOfSquaresShort(x: Int, y: Int): Int = x * x + y * y
 
 
-// Syntax für Funktionsaufrufe:  
+// Syntax für Funktionsaufrufe:
 
 sumOfSquares(3, 4)  // => 25
 
 
-// In den meisten Fällen (mit Ausnahme von rekursiven Funktionen), können  
-// Rückgabetypen auch weggelassen werden, da dieselbe Typ Inference, wie bei  
-// Variablen, auch bei Funktionen greift:  
+// In den meisten Fällen (mit Ausnahme von rekursiven Funktionen), können
+// Rückgabetypen auch weggelassen werden, da dieselbe Typ Inference, wie bei
+// Variablen, auch bei Funktionen greift:
 
 def sq(x: Int) = x * x  // Compiler errät, dass der return type Int ist
 
 
-// Funktionen können default parameter haben:  
+// Funktionen können default parameter haben:
 
 def addWithDefault(x: Int, y: Int = 5) = x + y
 addWithDefault(1, 2) // => 3
 addWithDefault(1)    // => 6
 
 
-// Anonyme Funktionen sehen so aus:  
+// Anonyme Funktionen sehen so aus:
 
 (x: Int) => x * x
 
 
-// Im Gegensatz zu def bei normalen Funktionen, kann bei anonymen Funktionen   
-// sogar der Eingabetyp weggelassen werden, wenn der Kontext klar ist.  
-// Beachte den Typ "Int => Int", dies beschreibt eine Funktion,  
-// welche Int als Parameter erwartet und Int zurückgibt.  
+// Im Gegensatz zu def bei normalen Funktionen, kann bei anonymen Funktionen
+// sogar der Eingabetyp weggelassen werden, wenn der Kontext klar ist.
+// Beachte den Typ "Int => Int", dies beschreibt eine Funktion,
+// welche Int als Parameter erwartet und Int zurückgibt.
 
 val sq: Int => Int = x => x * x
 
 
-// Anonyme Funktionen benutzt man ganz normal:  
+// Anonyme Funktionen benutzt man ganz normal:
 
 sq(10)   // => 100
 
 
-// Wenn ein Parameter einer anonymen Funktion nur einmal verwendet wird,  
-// bietet Scala einen sehr kurzen Weg diesen Parameter zu benutzen,  
-// indem die Parameter als Unterstrich "_" in der Parameterreihenfolge  
-// verwendet werden. Diese anonymen Funktionen werden sehr häufig   
-// verwendet.  
+// Wenn ein Parameter einer anonymen Funktion nur einmal verwendet wird,
+// bietet Scala einen sehr kurzen Weg diesen Parameter zu benutzen,
+// indem die Parameter als Unterstrich "_" in der Parameterreihenfolge
+// verwendet werden. Diese anonymen Funktionen werden sehr häufig
+// verwendet.
 
-val addOne: Int => Int = _ + 1  
-val weirdSum: (Int, Int) => Int = (_ * 2 + _ * 3)  
-addOne(5)      // => 6  
-weirdSum(2, 4) // => 16  
+val addOne: Int => Int = _ + 1
+val weirdSum: (Int, Int) => Int = (_ * 2 + _ * 3)
+addOne(5)      // => 6
+weirdSum(2, 4) // => 16
 
 
-// Es gibt einen keyword return in Scala. Allerdings ist seine Verwendung  
-// nicht immer ratsam und kann fehlerbehaftet sein. "return" gibt nur aus  
-// dem innersten def, welches den return Ausdruck umgibt, zurück.  
-// "return" hat keinen Effekt in anonymen Funktionen:  
+// Es gibt einen keyword return in Scala. Allerdings ist seine Verwendung
+// nicht immer ratsam und kann fehlerbehaftet sein. "return" gibt nur aus
+// dem innersten def, welches den return Ausdruck umgibt, zurück.
+// "return" hat keinen Effekt in anonymen Funktionen:
 
-def foo(x: Int): Int = {  
-  val anonFunc: Int => Int = { z =>  
-    if (z > 5)  
-      return z // Zeile macht z zum return Wert von foo  
-    else  
-      z + 2    // Zeile ist der return Wert von anonFunc  
-  }  
-  anonFunc(x)  // Zeile ist der return Wert von foo  
-}  
+def foo(x: Int): Int = {
+  val anonFunc: Int => Int = { z =>
+    if (z > 5)
+      return z // Zeile macht z zum return Wert von foo
+    else
+      z + 2    // Zeile ist der return Wert von anonFunc
+  }
+  anonFunc(x)  // Zeile ist der return Wert von foo
+}
 
 
 /////////////////////////////////////////////////
@@ -280,25 +280,25 @@ val r = 1 to 5
 r.foreach(println)
 r foreach println
 (5 to 1 by -1) foreach (println)
-  
-// Scala ist syntaktisch sehr großzügig, Semikolons am Zeilenende  
-// sind optional, beim Aufruf von Methoden können die Punkte  
-// und Klammern entfallen und Operatoren sind im Grunde austauschbare Methoden  
 
-// while Schleife  
+// Scala ist syntaktisch sehr großzügig, Semikolons am Zeilenende
+// sind optional, beim Aufruf von Methoden können die Punkte
+// und Klammern entfallen und Operatoren sind im Grunde austauschbare Methoden
+
+// while Schleife
 
 var i = 0
 while (i < 10) { println("i " + i); i += 1 }
 i    // i ausgeben, res3: Int = 10
 
 
-// Beachte: while ist eine Schleife im klassischen Sinne -  
-// Sie läuft sequentiell ab und verändert die loop-Variable.  
-// While in Scala läuft schneller ab als in Java und die o.g.  
-// Kombinatoren und Zusammenlegungen sind einfacher zu verstehen  
+// Beachte: while ist eine Schleife im klassischen Sinne -
+// Sie läuft sequentiell ab und verändert die loop-Variable.
+// While in Scala läuft schneller ab als in Java und die o.g.
+// Kombinatoren und Zusammenlegungen sind einfacher zu verstehen
 // und zu parellelisieren.
 
-// Ein do while Schleife  
+// Ein do while Schleife
 
 do {
   println("x ist immer noch weniger wie 10")
@@ -306,10 +306,10 @@ do {
 } while (x < 10)
 
 
-// Endrekursionen sind ideomatisch um sich wiederholende  
-// Dinge in Scala zu lösen. Rekursive Funtionen benötigen explizit einen  
-// return Typ, der Compiler kann ihn nicht erraten.  
-// Unit, in diesem Beispiel.  
+// Endrekursionen sind ideomatisch um sich wiederholende
+// Dinge in Scala zu lösen. Rekursive Funtionen benötigen explizit einen
+// return Typ, der Compiler kann ihn nicht erraten.
+// Unit, in diesem Beispiel.
 
 def showNumbersInRange(a: Int, b: Int): Unit = {
   print(a)
@@ -360,7 +360,7 @@ val s = Set(1,1,3,3,7)
 s: scala.collection.immutable.Set[Int] = Set(1, 3, 7)
 
 // Tuple - Speichert beliebige Daten und "verbindet" sie miteinander
-// Ein Tuple ist keine Collection.  
+// Ein Tuple ist keine Collection.
 
 (1, 2)
 (4, 3, 2)
@@ -368,15 +368,15 @@ s: scala.collection.immutable.Set[Int] = Set(1, 3, 7)
 (a, 2, "three")
 
 
-// Hier ist der Rückgabewert der Funktion ein Tuple  
-// Die Funktion gibt das Ergebnis, so wie den Rest zurück.  
+// Hier ist der Rückgabewert der Funktion ein Tuple
+// Die Funktion gibt das Ergebnis, so wie den Rest zurück.
 
 val divideInts = (x: Int, y: Int) => (x / y, x % y)
 divideInts(10, 3)
 
 
-// Um die Elemente eines Tuples anzusprechen, benutzt man diese  
-// Notation: _._n wobei n der index des Elements ist (Index startet bei 1)  
+// Um die Elemente eines Tuples anzusprechen, benutzt man diese
+// Notation: _._n wobei n der index des Elements ist (Index startet bei 1)
 
 val d = divideInts(10, 3)
 d._1
@@ -388,32 +388,32 @@ d._2
 /////////////////////////////////////////////////
 
 /*
-  Bislang waren alle gezeigten Sprachelemente einfache Ausdrücke, welche zwar  
-  zum Ausprobieren und Lernen in der REPL gut geeignet sind, jedoch in  
-  einem Scala file selten alleine zu finden sind.  
-  Die einzigen Top-Level Konstrukte in Scala sind nämlich:  
+  Bislang waren alle gezeigten Sprachelemente einfache Ausdrücke, welche zwar
+  zum Ausprobieren und Lernen in der REPL gut geeignet sind, jedoch in
+  einem Scala file selten alleine zu finden sind.
+  Die einzigen Top-Level Konstrukte in Scala sind nämlich:
 
   - Klassen (classes)
   - Objekte (objects)
   - case classes
   - traits
 
-  Diesen Sprachelemente wenden wir uns jetzt zu.  
+  Diesen Sprachelemente wenden wir uns jetzt zu.
 */
 
 // Klassen
 
-// Zum Erstellen von Objekten benötigt man eine Klasse, wie in vielen  
-// anderen Sprachen auch. 
+// Zum Erstellen von Objekten benötigt man eine Klasse, wie in vielen
+// anderen Sprachen auch.
 
-// erzeugt Klasse mit default Konstruktor  
+// erzeugt Klasse mit default Konstruktor
 
 class Hund
 scala> val t = new Hund
 t: Hund = Hund@7103745
 
 
-// Der Konstruktor wird direkt hinter dem Klassennamen deklariert.  
+// Der Konstruktor wird direkt hinter dem Klassennamen deklariert.
 
 class Hund(sorte: String)
 scala> val t = new Hund("Dackel")
@@ -421,8 +421,8 @@ t: Hund = Hund@14be750c
 scala> t.sorte //error: value sorte is not a member of Hund
 
 
-// Per val wird aus dem Attribut ein unveränderliches Feld der Klasse  
-// Per var wird aus dem Attribut ein veränderliches Feld der Klasse  
+// Per val wird aus dem Attribut ein unveränderliches Feld der Klasse
+// Per var wird aus dem Attribut ein veränderliches Feld der Klasse
 
 class Hund(val sorte: String)
 scala> val t = new Hund("Dackel")
@@ -431,14 +431,14 @@ scala> t.sorte
 res18: String = Dackel
 
 
-// Methoden werden mit def geschrieben  
+// Methoden werden mit def geschrieben
 
 def bark = "Woof, woof!"
 
 
-// Felder und Methoden können public, protected und private sein  
-// default ist public  
-// private ist nur innerhalb des deklarierten Bereichs sichtbar  
+// Felder und Methoden können public, protected und private sein
+// default ist public
+// private ist nur innerhalb des deklarierten Bereichs sichtbar
 
 class Hund {
   private def x = ...
@@ -446,8 +446,8 @@ class Hund {
 }
 
 
-// protected ist nur innerhalb des deklarierten und aller  
-// erbenden Bereiche sichtbar  
+// protected ist nur innerhalb des deklarierten und aller
+// erbenden Bereiche sichtbar
 
 class Hund {
   protected def x = ...
@@ -457,12 +457,12 @@ class Dackel extends Hund {
 }
 
 // Object
-// Wird ein Objekt ohne das Schlüsselwort "new" instanziert, wird das sog.  
-// "companion object" aufgerufen. Mit dem "object" Schlüsselwort wird so  
-// ein Objekt (Typ UND Singleton) erstellt. Damit kann man dann eine Klasse  
-// benutzen ohne ein Objekt instanziieren zu müssen.  
-// Ein gültiges companion Objekt einer Klasse ist es aber erst dann, wenn  
-// es genauso heisst und in derselben Datei wie die Klasse definiert wurde.  
+// Wird ein Objekt ohne das Schlüsselwort "new" instanziert, wird das sog.
+// "companion object" aufgerufen. Mit dem "object" Schlüsselwort wird so
+// ein Objekt (Typ UND Singleton) erstellt. Damit kann man dann eine Klasse
+// benutzen ohne ein Objekt instanziieren zu müssen.
+// Ein gültiges companion Objekt einer Klasse ist es aber erst dann, wenn
+// es genauso heisst und in derselben Datei wie die Klasse definiert wurde.
 
 object Hund {
   def alleSorten = List("Pitbull", "Dackel", "Retriever")
@@ -470,50 +470,50 @@ object Hund {
 }
 
 // Case classes
-// Fallklassen bzw. Case classes sind Klassen die normale Klassen um extra  
-// Funktionalität erweitern. Mit Case Klassen bekommt man ein paar  
-// Dinge einfach dazu, ohne sich darum kümmern zu müssen. Z.B.  
-// ein companion object mit den entsprechenden Methoden,  
-// Hilfsmethoden wie toString(), equals() und hashCode() und auch noch  
-// Getter für unsere Attribute (das Angeben von val entfällt dadurch)  
+// Fallklassen bzw. Case classes sind Klassen die normale Klassen um extra
+// Funktionalität erweitern. Mit Case Klassen bekommt man ein paar
+// Dinge einfach dazu, ohne sich darum kümmern zu müssen. Z.B.
+// ein companion object mit den entsprechenden Methoden,
+// Hilfsmethoden wie toString(), equals() und hashCode() und auch noch
+// Getter für unsere Attribute (das Angeben von val entfällt dadurch)
 
 class Person(val name: String)
 class Hund(val sorte: String, val farbe: String, val halter: Person)
 
 
-// Es genügt das Schlüsselwort case vor die Klasse zu schreiben.  
+// Es genügt das Schlüsselwort case vor die Klasse zu schreiben.
 
 case class Person(name: String)
 case class Hund(sorte: String, farbe: String, halter: Person)
 
 
-// Für neue Instanzen brauch man kein "new"  
+// Für neue Instanzen brauch man kein "new"
 
 val dackel = Hund("dackel", "grau", Person("peter"))
 val dogge = Hund("dogge", "grau", Person("peter"))
-  
 
-// getter  
+
+// getter
 
 dackel.halter  // => Person = Person(peter)
 
-  
-// equals  
+
+// equals
 
 dogge == dackel  // => false
 
-  
-// copy  
-// otherGeorge == Person("george", "9876")  
+
+// copy
+// otherGeorge == Person("george", "9876")
 
 val otherGeorge = george.copy(phoneNumber = "9876")
 
 // Traits
-// Ähnlich wie Java interfaces, definiert man mit traits einen Objekttyp  
-// und Methodensignaturen. Scala erlaubt allerdings das teilweise  
-// implementieren dieser Methoden. Konstruktorparameter sind nicht erlaubt.  
-// Traits können von anderen Traits oder Klassen erben, aber nur von  
-// parameterlosen.  
+// Ähnlich wie Java interfaces, definiert man mit traits einen Objekttyp
+// und Methodensignaturen. Scala erlaubt allerdings das teilweise
+// implementieren dieser Methoden. Konstruktorparameter sind nicht erlaubt.
+// Traits können von anderen Traits oder Klassen erben, aber nur von
+// parameterlosen.
 
 trait Hund {
 	def sorte: String
@@ -527,16 +527,16 @@ class Bernhardiner extends Hund{
 	def beissen = false
 }
 
-  
 
-scala> b  
-res0: Bernhardiner = Bernhardiner@3e57cd70  
-scala> b.sorte  
-res1: String = Bernhardiner  
-scala> b.bellen  
-res2: Boolean = true  
-scala> b.beissen  
-res3: Boolean = false  
+
+scala> b
+res0: Bernhardiner = Bernhardiner@3e57cd70
+scala> b.sorte
+res1: String = Bernhardiner
+scala> b.bellen
+res2: Boolean = true
+scala> b.beissen
+res3: Boolean = false
 
 // Ein Trait kann auch als Mixin eingebunden werden. Die Klasse erbt vom
 // ersten Trait mit dem Schlüsselwort "extends", während weitere Traits
@@ -562,11 +562,11 @@ res0: String = Woof
 // 6. Pattern Matching
 /////////////////////////////////////////////////
 
-// Pattern matching in Scala ist ein sehr nützliches und wesentlich  
-// mächtigeres Feature als Vergleichsfunktionen in Java. In Scala  
-// benötigt ein case Statement kein "break", ein fall-through gibt es nicht.  
-// Mehrere Überprüfungen können mit einem Statement gemacht werden.  
-// Pattern matching wird mit dem Schlüsselwort "match" gemacht.  
+// Pattern matching in Scala ist ein sehr nützliches und wesentlich
+// mächtigeres Feature als Vergleichsfunktionen in Java. In Scala
+// benötigt ein case Statement kein "break", ein fall-through gibt es nicht.
+// Mehrere Überprüfungen können mit einem Statement gemacht werden.
+// Pattern matching wird mit dem Schlüsselwort "match" gemacht.
 
 val x = ...
 x match {
@@ -576,7 +576,7 @@ x match {
 }
 
 
-// Pattern Matching kann auf beliebige Typen prüfen  
+// Pattern Matching kann auf beliebige Typen prüfen
 
 val any: Any = ...
 val gleicht = any match {
@@ -588,7 +588,7 @@ val gleicht = any match {
 }
 
 
-// und auf Objektgleichheit  
+// und auf Objektgleichheit
 
 def matchPerson(person: Person): String = person match {
   case Person("George", nummer) => "George! Die Nummer ist " + number
@@ -597,7 +597,7 @@ def matchPerson(person: Person): String = person match {
 }
 
 
-// Und viele mehr...  
+// Und viele mehr...
 
 val email = "(.*)@(.*)".r  // regex
 def matchEverything(obj: Any): String = obj match {
@@ -620,8 +620,8 @@ def matchEverything(obj: Any): String = obj match {
 }
 
 
-// Jedes Objekt mit einer "unapply" Methode kann per Pattern geprüft werden  
-// Ganze Funktionen können Patterns sein  
+// Jedes Objekt mit einer "unapply" Methode kann per Pattern geprüft werden
+// Ganze Funktionen können Patterns sein
 
 val patternFunc: Person => String = {
   case Person("George", number) => s"George's number: $number"
@@ -633,13 +633,13 @@ val patternFunc: Person => String = {
 // 37. Higher-order functions
 /////////////////////////////////////////////////
 
-Scala erlaubt, das Methoden und Funktion wiederum Funtionen und Methoden  
-als Aufrufparameter oder Return Wert verwenden. Diese Methoden heissen  
-higher-order functions  
-Es gibt zahlreiche higher-order functions nicht nur für Listen, auch für  
-die meisten anderen Collection Typen, sowie andere Klassen in Scala  
-Nennenswerte sind:  
-"filter", "map", "reduce", "foldLeft"/"foldRight", "exists", "forall"  
+Scala erlaubt, das Methoden und Funktion wiederum Funtionen und Methoden
+als Aufrufparameter oder Return Wert verwenden. Diese Methoden heissen
+higher-order functions
+Es gibt zahlreiche higher-order functions nicht nur für Listen, auch für
+die meisten anderen Collection Typen, sowie andere Klassen in Scala
+Nennenswerte sind:
+"filter", "map", "reduce", "foldLeft"/"foldRight", "exists", "forall"
 
 ## List
 
@@ -649,39 +649,39 @@ val resultExists4 = list.exists(isEqualToFour)
 
 
 ## map
-// map nimmt eine Funktion und führt sie auf jedem Element aus und erzeugt  
-// eine neue Liste  
-  
-// Funktion erwartet ein Int und returned ein Int  
+// map nimmt eine Funktion und führt sie auf jedem Element aus und erzeugt
+// eine neue Liste
 
-val add10: Int => Int = _ + 10 
+// Funktion erwartet ein Int und returned ein Int
 
+val add10: Int => Int = _ + 10
 
-// add10 wird auf jedes Element angewendet  
+
+// add10 wird auf jedes Element angewendet
 
 List(1, 2, 3) map add10 // => List(11, 12, 13)
 
 
-// Anonyme Funktionen können anstatt definierter Funktionen verwendet werden  
+// Anonyme Funktionen können anstatt definierter Funktionen verwendet werden
 
 List(1, 2, 3) map (x => x + 10)
 
 
-// Der Unterstrich wird anstelle eines Parameters einer anonymen Funktion  
-// verwendet. Er wird an die Variable gebunden.  
+// Der Unterstrich wird anstelle eines Parameters einer anonymen Funktion
+// verwendet. Er wird an die Variable gebunden.
 
 List(1, 2, 3) map (_ + 10)
 
 
-// Wenn der anonyme Block und die Funtion beide EIN Argument erwarten,  
-// kann sogar der Unterstrich weggelassen werden.  
+// Wenn der anonyme Block und die Funtion beide EIN Argument erwarten,
+// kann sogar der Unterstrich weggelassen werden.
 
 List("Dom", "Bob", "Natalia") foreach println
 
 
 // filter
-// filter nimmt ein Prädikat (eine Funktion von A -> Boolean) und findet  
-// alle Elemente die auf das Prädikat passen  
+// filter nimmt ein Prädikat (eine Funktion von A -> Boolean) und findet
+// alle Elemente die auf das Prädikat passen
 
 List(1, 2, 3) filter (_ > 2) // => List(3)
 case class Person(name: String, age: Int)
@@ -692,19 +692,19 @@ List(
 
 
 // reduce
-// reduce nimmt zwei Elemente und kombiniert sie zu einem Element,  
-// und zwar solange bis nur noch ein Element da ist.  
+// reduce nimmt zwei Elemente und kombiniert sie zu einem Element,
+// und zwar solange bis nur noch ein Element da ist.
 
 // foreach
-// foreach gibt es für einige Collections  
+// foreach gibt es für einige Collections
 
 val aListOfNumbers = List(1, 2, 3, 4, 10, 20, 100)
 aListOfNumbers foreach (x => println(x))
 aListOfNumbers foreach println
 
 // For comprehensions
-// Eine for-comprehension definiert eine Beziehung zwischen zwei Datensets.  
-// Dies ist keine for-Schleife.  
+// Eine for-comprehension definiert eine Beziehung zwischen zwei Datensets.
+// Dies ist keine for-Schleife.
 
 for { n <- s } yield sq(n)
 val nSquared2 = for { n <- s } yield sq(n)
@@ -716,58 +716,58 @@ for { n <- s; nSquared = n * n if nSquared < 10} yield nSquared
 // 8. Implicits
 /////////////////////////////////////////////////
 
-// **ACHTUNG:**  
+// **ACHTUNG:**
 // Implicits sind ein sehr mächtiges Sprachfeature von Scala.
-// Es sehr einfach  
-// sie falsch zu benutzen und Anfänger sollten sie mit Vorsicht oder am  
-// besten erst dann benutzen, wenn man versteht wie sie funktionieren.  
-// Dieses Tutorial enthält Implicits, da sie in Scala an jeder Stelle  
-// vorkommen und man auch mit einer Lib die Implicits benutzt nichts sinnvolles  
-// machen kann.  
-// Hier soll ein Grundverständnis geschaffen werden, wie sie funktionieren.  
+// Es sehr einfach
+// sie falsch zu benutzen und Anfänger sollten sie mit Vorsicht oder am
+// besten erst dann benutzen, wenn man versteht wie sie funktionieren.
+// Dieses Tutorial enthält Implicits, da sie in Scala an jeder Stelle
+// vorkommen und man auch mit einer Lib die Implicits benutzt nichts sinnvolles
+// machen kann.
+// Hier soll ein Grundverständnis geschaffen werden, wie sie funktionieren.
 
-// Mit dem Schlüsselwort implicit können Methoden, Werte, Funktion, Objekte  
-// zu "implicit Methods" werden.  
+// Mit dem Schlüsselwort implicit können Methoden, Werte, Funktion, Objekte
+// zu "implicit Methods" werden.
 
 implicit val myImplicitInt = 100
 implicit def myImplicitFunction(sorte: String) = new Hund("Golden " + sorte)
 
 
-// implicit ändert nicht das Verhalten eines Wertes oder einer Funktion  
+// implicit ändert nicht das Verhalten eines Wertes oder einer Funktion
 
 myImplicitInt + 2                   // => 102
 myImplicitFunction("Pitbull").sorte // => "Golden Pitbull"
 
 
-// Der Unterschied ist, dass diese Werte ausgewählt werden können, wenn ein  
-// anderer Codeteil einen implicit Wert benötigt, zum Beispiel innerhalb von  
-// implicit Funktionsparametern  
-  
-// Diese Funktion hat zwei Parameter: einen normalen und einen implicit  
+// Der Unterschied ist, dass diese Werte ausgewählt werden können, wenn ein
+// anderer Codeteil einen implicit Wert benötigt, zum Beispiel innerhalb von
+// implicit Funktionsparametern
+
+// Diese Funktion hat zwei Parameter: einen normalen und einen implicit
 
 def sendGreetings(toWhom: String)(implicit howMany: Int) =
   s"Hello $toWhom, $howMany blessings to you and yours!"
 
 
-// Werden beide Parameter gefüllt, verhält sich die Funktion wie erwartet  
+// Werden beide Parameter gefüllt, verhält sich die Funktion wie erwartet
 
 sendGreetings("John")(1000)  // => "Hello John, 1000 blessings to you and yours!"
 
 
-// Wird der implicit Parameter jedoch weggelassen, wird ein anderer  
-// implicit Wert vom gleichen Typ genommen. Der Compiler sucht im  
-// lexikalischen Scope und im companion object nach einem implicit Wert,  
-// der vom Typ passt, oder  nach einer implicit Methode mit der er in den  
-// geforderten Typ konvertieren kann.  
-  
-// Hier also: "myImplicitInt", da ein Int gesucht wird  
+// Wird der implicit Parameter jedoch weggelassen, wird ein anderer
+// implicit Wert vom gleichen Typ genommen. Der Compiler sucht im
+// lexikalischen Scope und im companion object nach einem implicit Wert,
+// der vom Typ passt, oder  nach einer implicit Methode mit der er in den
+// geforderten Typ konvertieren kann.
+
+// Hier also: "myImplicitInt", da ein Int gesucht wird
 
 sendGreetings("Jane")  // => "Hello Jane, 100 blessings to you and yours!"
 
 
-// bzw. "myImplicitFunction"  
-// Der String wird erst mit Hilfe der Funktion in Hund konvertiert, und  
-// dann wird die Methode aufgerufen  
+// bzw. "myImplicitFunction"
+// Der String wird erst mit Hilfe der Funktion in Hund konvertiert, und
+// dann wird die Methode aufgerufen
 
 "Retriever".sorte // => "Golden Retriever"
 
@@ -780,27 +780,27 @@ sendGreetings("Jane")  // => "Hello Jane, 100 blessings to you and yours!"
 import scala.collection.immutable.List
 
 
-// Importiere alle Unterpackages  
+// Importiere alle Unterpackages
 
 import scala.collection.immutable._
 
 
-// Importiere verschiedene Klassen mit einem Statement  
+// Importiere verschiedene Klassen mit einem Statement
 
 import scala.collection.immutable.{List, Map}
 
 
-// Einen Import kann man mit '=>' umbenennen  
+// Einen Import kann man mit '=>' umbenennen
 
 import scala.collection.immutable.{List => ImmutableList}
 
 
-// Importiere alle Klasses, mit Ausnahem von....  
-// Hier ohne: Map and Set:  
+// Importiere alle Klasses, mit Ausnahem von....
+// Hier ohne: Map and Set:
 
 import scala.collection.immutable.{Map => _, Set => _, _}
 
-// Main 
+// Main
 
 object Application {
   def main(args: Array[String]): Unit = {
@@ -810,14 +810,14 @@ object Application {
 
 
 // I/O
-// Eine Datei Zeile für Zeile lesen  
+// Eine Datei Zeile für Zeile lesen
 
 import scala.io.Source
 for(line <- Source.fromFile("myfile.txt").getLines())
   println(line)
 
 
-// Eine Datei schreiben  
+// Eine Datei schreiben
 
 val writer = new PrintWriter("myfile.txt")
 writer.write("Schreibe Zeile" + util.Properties.lineSeparator)
@@ -826,7 +826,7 @@ writer.close()
 
 ```
 
-## Weiterführende Hinweise 
+## Weiterführende Hinweise
 
 // DE
 * [Scala Tutorial](https://scalatutorial.wordpress.com)
-- 
cgit v1.2.3


From 147907afc60e9cf1581e6a9dfae5492cf2e203fb Mon Sep 17 00:00:00 2001
From: Jonas Friedemann Grote <jonas.grote@vico-research.com>
Date: Fri, 8 Sep 2017 13:54:54 +0200
Subject: Review translation.

---
 de-de/scala-de.html.markdown | 221 ++++++++++++++++++++++---------------------
 1 file changed, 111 insertions(+), 110 deletions(-)

(limited to 'de-de')

diff --git a/de-de/scala-de.html.markdown b/de-de/scala-de.html.markdown
index ddce3f6b..8b0dc5f0 100644
--- a/de-de/scala-de.html.markdown
+++ b/de-de/scala-de.html.markdown
@@ -8,6 +8,7 @@ contributors:
     - ["Dennis Keller", "github.com/denniskeller"]
 translators:
   - ["Christian Albrecht", "https://github.com/coastalchief"]
+  - ["Jonas Grote", "https://github.com/exic"]
 filename: learnscala-de.scala
 lang: de-de
 ---
@@ -19,11 +20,11 @@ der EPFL (Lausanne / Schweiz) unter der Leitung von Martin Odersky entwickelt.
 
 ```scala
 /*
-Scala Umgebung einrichten:
+Scala-Umgebung einrichten:
 
 1. Scala binaries herunterladen- http://www.scala-lang.org/downloads
 2. Unzip/untar in ein Verzeichnis
-3. das bin Unterverzeichnis der `PATH` Umgebungsvariable hinzufügen
+3. das Unterverzeichnis `bin` der `PATH`-Umgebungsvariable hinzufügen
 4. Mit dem Kommando `scala` wird die REPL gestartet und zeigt als Prompt:
 
 scala>
@@ -31,47 +32,47 @@ scala>
 Die REPL (Read-Eval-Print Loop) ist der interaktive Scala Interpreter.
 Hier kann man jeden Scala Ausdruck verwenden und das Ergebnis wird direkt
 ausgegeben.
-Als nächstes beschäftigen wir uns mit ein paar Scala Basics.
+Als nächstes beschäftigen wir uns mit ein paar Scala-Grundlagen.
 */
 
 
 /////////////////////////////////////////////////
-// 1. Basics
+// 1. Grundlagen
 /////////////////////////////////////////////////
 
-// Einzeilige Kommentare beginnen mit zwei Slashes
+// Einzeilige Kommentare beginnen mit zwei Slashes.
 
 /*
-  Mehrzeilige Kommentare, starten
-  mit einem Slash-Stern und enden mit einem Stern-Slash
+  Mehrzeilige Kommentare starten mit einem Slash-Stern
+  und enden mit einem Stern-Slash.
 */
 
-// Einen Wert, und eine zusätzliche neue Zeile ausgeben
+// Einen Wert und eine zusätzliche neue Zeile ausgeben:
 
 println("Hello world!")
 println(10)
 
 
-// Einen Wert, ohne eine zusätzliche neue Zeile ausgeben
+// Einen Wert ohne eine zusätzliche neue Zeile ausgeben:
 
 print("Hello world")
 
 /*
   Variablen werden entweder mit var oder val deklariert.
-  Deklarationen mit val sind immutable, also unveränderlich
-  Deklarationen mit var sind mutable, also veränderlich
+  Deklarationen mit val sind immutable, also unveränderlich.
+  Deklarationen mit var sind mutable, also veränderlich.
   Immutability ist gut.
 */
 val x = 10 // x ist 10
-x = 20     // error: reassignment to val
+x = 20     // Error: reassignment to val (Fehler: neue Zuweisung zu einem unveränderlichen Wert)
 var y = 10
 y = 20     // y ist jetzt 20
 
 /*
 Scala ist eine statisch getypte Sprache, auch wenn wir in dem o.g. Beispiel
 keine Typen an x und y geschrieben haben.
-In Scala ist etwas eingebaut, was sich Type Inference nennt. Das heißt das der
-Scala Compiler in den meisten Fällen erraten kann, von welchen Typ eine Variable ist,
+In Scala ist etwas eingebaut, was sich Type Inference nennt. Das heißt, dass der
+Scala Compiler in den meisten Fällen erraten kann, von welchem Typ eine Variable ist,
 so dass der Typ nicht jedes mal angegeben werden muss.
 Einen Typ gibt man bei einer Variablendeklaration wie folgt an:
 */
@@ -79,18 +80,18 @@ val z: Int = 10
 val a: Double = 1.0
 
 
-// Bei automatischer Umwandlung von Int auf Double wird aus 10 eine 10.0
+// Bei automatischer Umwandlung von Int auf Double wird aus 10 eine 10.0:
 
 val b: Double = 10
 
 
-// Boolean Werte
+// Boolean-Werte:
 
 true
 false
 
 
-// Boolean Operationen
+// Boolean-Operationen:
 
 !true         // false
 !false        // true
@@ -98,7 +99,7 @@ true == false // false
 10 > 5        // true
 
 
-// Mathematische Operationen sind wie gewohnt
+// Mathematische Operationen sind wie gewohnt:
 
 1 + 1   // 2
 2 - 1   // 1
@@ -109,73 +110,72 @@ true == false // false
 
 
 // Die Auswertung eines Ausdrucks in der REPL gibt den Typ
-// und das Ergebnis zurück.
+// und das Ergebnis zurück:
 
   scala> 1 + 7
   res29: Int = 8
 
 /*
 Das bedeutet, dass das Resultat der Auswertung von 1 + 7 ein Objekt
-von Typ Int ist und einen Wert 0 hat.
-"res29" ist ein sequentiell generierter name, um das Ergebnis des
+von Typ Int ist und einen Wert 8 hat.
+"res29" ist ein sequentiell generierter Name, um das Ergebnis des
 Ausdrucks zu speichern. Dieser Wert kann bei Dir anders sein...
 */
 
 "Scala strings werden in doppelten Anführungszeichen eingeschlossen"
-'a' // A Scala Char
-// 'Einzeln ge-quotete strings gibt es nicht!' <= This causes an error
+'a' // Ein Scala Char
+// 'Einzeln ge-quotete strings gibt es nicht!' <= Das erzeugt einen Fehler!
 
-// Für Strings gibt es die üblichen Java Methoden
+// Für Strings gibt es die üblichen Java-Methoden:
 
 "hello world".length
 "hello world".substring(2, 6)
 "hello world".replace("C", "3")
 
 
-// Zusätzlich gibt es noch extra Scala Methoden
+// Zusätzlich gibt es noch extra Scala-Methoden
 // siehe: scala.collection.immutable.StringOps
 
 "hello world".take(5)
 "hello world".drop(5)
 
 
-// String interpolation: prefix "s"
+// String-Interpolation: prefix "s":
 
 val n = 45
-s"We have $n apples" // => "We have 45 apples"
+s"Wir haben $n Äpfel" // => "Wir haben 45 Äpfel"
 
 
-// Ausdrücke im Innern von interpolierten Strings gibt es auch
+// Ausdrücke im Innern von interpolierten Strings gibt es auch:
 
 val a = Array(11, 9, 6)
-val n = 100
-s"My second daughter is ${a(0) - a(2)} years old."    // => "My second daughter is 5 years old."
-s"We have double the amount of ${n / 2.0} in apples." // => "We have double the amount of 22.5 in apples."
-s"Power of 2: ${math.pow(2, 2)}"                      // => "Power of 2: 4"
+s"Meine zweite Tochter ist ${a(0) - a(2)} Jahre alt."    // => "Meine zweite Tochter ist 5 Jahre alt."
+s"Wir haben das Doppelte von ${n / 2.0} an Äpfeln." // => "Wir haben das Doppelte von 22.5 an Äpfeln."
+s"2 im Quadrat: ${math.pow(2, 2)}"                      // => "2 im Quadrat: 4"
 
 
-// Formatierung der interpolierten Strings mit dem prefix "f"
+// Formatierung der interpolierten Strings mit dem prefix "f":
 
-f"Power of 5: ${math.pow(5, 2)}%1.0f"         // "Power of 5: 25"
-f"Square root of 122: ${math.sqrt(122)}%1.4f" // "Square root of 122: 11.0454"
+f"5 im Quadrat: ${math.pow(5, 2)}%1.0f"         // "5 im Quadrat: 25"
+f"Quadratwurzel von 122: ${math.sqrt(122)}%1.4f" // "Quadratwurzel von 122: 11.0454"
 
 
-// Raw Strings, ignorieren Sonderzeichen.
+// Raw Strings ignorieren Sonderzeichen:
 
 raw"New line feed: \n. Carriage return: \r." // => "New line feed: \n. Carriage return: \r."
 
 
 // Manche Zeichen müssen "escaped" werden, z.B.
-// ein doppeltes Anführungszeichen in innern eines Strings.
+// ein doppeltes Anführungszeichen im Innern eines Strings:
 
-"They stood outside the \"Rose and Crown\"" // => "They stood outside the "Rose and Crown""
+"Sie standen vor der \"Rose and Crown\"" // => "Sie standen vor der "Rose and Crown""
 
 
 // Dreifache Anführungszeichen erlauben es, dass ein String über mehrere Zeilen geht
-// und Anführungszeichen enthalten kann.
+// und Anführungszeichen enthalten kann:
 
-val html = """<form id="daform">
-                <p>Press belo', Joe</p>
+val html = """<form id="dieform">
+                <p>Drück belo', Joe</p>
                 <input type="submit">
               </form>"""
 
@@ -184,12 +184,12 @@ val html = """<form id="daform">
 // 2. Funktionen
 /////////////////////////////////////////////////
 
-// Funktionen werden so definiert
+// Funktionen werden so definiert:
 //
 //   def functionName(args...): ReturnType = { body... }
 //
-// Beachte: Es gibt kein return Schlüsselwort. In Scala ist der letzte Ausdruck
-// in einer Funktion der Rückgabewert.
+// Beachte: Es wird hier kein Schlüsselwort "return" verwendet.
+// In Scala ist der letzte Ausdruck in einer Funktion der Rückgabewert.
 
 def sumOfSquares(x: Int, y: Int): Int = {
   val x2 = x * x
@@ -209,14 +209,14 @@ def sumOfSquaresShort(x: Int, y: Int): Int = x * x + y * y
 sumOfSquares(3, 4)  // => 25
 
 
-// In den meisten Fällen (mit Ausnahme von rekursiven Funktionen), können
-// Rückgabetypen auch weggelassen werden, da dieselbe Typ Inference, wie bei
+// In den meisten Fällen (mit Ausnahme von rekursiven Funktionen) können
+// Rückgabetypen auch weggelassen werden, da dieselbe Typ-Inferenz, wie bei
 // Variablen, auch bei Funktionen greift:
 
 def sq(x: Int) = x * x  // Compiler errät, dass der return type Int ist
 
 
-// Funktionen können default parameter haben:
+// Funktionen können Default-Parameter haben:
 
 def addWithDefault(x: Int, y: Int = 5) = x + y
 addWithDefault(1, 2) // => 3
@@ -253,7 +253,7 @@ addOne(5)      // => 6
 weirdSum(2, 4) // => 16
 
 
-// Es gibt einen keyword return in Scala. Allerdings ist seine Verwendung
+// Es gibt ein Schlüsselwort "return" in Scala. Allerdings ist seine Verwendung
 // nicht immer ratsam und kann fehlerbehaftet sein. "return" gibt nur aus
 // dem innersten def, welches den return Ausdruck umgibt, zurück.
 // "return" hat keinen Effekt in anonymen Funktionen:
@@ -270,10 +270,10 @@ def foo(x: Int): Int = {
 
 
 /////////////////////////////////////////////////
-// 3. Flow Control
+// 3. Flusskontrolle
 /////////////////////////////////////////////////
 
-// Wertebereiche und Schleifen
+// Wertebereiche und Schleifen:
 
 1 to 5
 val r = 1 to 5
@@ -281,11 +281,11 @@ r.foreach(println)
 r foreach println
 (5 to 1 by -1) foreach (println)
 
-// Scala ist syntaktisch sehr großzügig, Semikolons am Zeilenende
+// Scala ist syntaktisch sehr großzügig; Semikolons am Zeilenende
 // sind optional, beim Aufruf von Methoden können die Punkte
-// und Klammern entfallen und Operatoren sind im Grunde austauschbare Methoden
+// und Klammern entfallen und Operatoren sind im Grunde austauschbare Methoden.
 
-// while Schleife
+// while Schleife:
 
 var i = 0
 while (i < 10) { println("i " + i); i += 1 }
@@ -294,22 +294,22 @@ i    // i ausgeben, res3: Int = 10
 
 // Beachte: while ist eine Schleife im klassischen Sinne -
 // Sie läuft sequentiell ab und verändert die loop-Variable.
-// While in Scala läuft schneller ab als in Java und die o.g.
+// "while" in Scala läuft schneller ab als in Java und die o.g.
 // Kombinatoren und Zusammenlegungen sind einfacher zu verstehen
 // und zu parellelisieren.
 
 // Ein do while Schleife
 
 do {
-  println("x ist immer noch weniger wie 10")
+  println("x ist immer noch weniger als 10")
   x += 1
 } while (x < 10)
 
 
-// Endrekursionen sind ideomatisch um sich wiederholende
-// Dinge in Scala zu lösen. Rekursive Funtionen benötigen explizit einen
-// return Typ, der Compiler kann ihn nicht erraten.
-// Unit, in diesem Beispiel.
+// Endrekursionen sind idiomatisch um sich wiederholende
+// Aufgaben in Scala zu lösen. Rekursive Funtionen benötigen explizit einen
+// Rückgabe-Typ, der Compiler kann ihn nicht erraten.
+// Der Rückgabe-Typ in diesem Beispiel ist Unit:
 
 def showNumbersInRange(a: Int, b: Int): Unit = {
   print(a)
@@ -331,7 +331,7 @@ val text = if (x == 10) "yeah" else "nope"
 
 
 /////////////////////////////////////////////////
-// 4. Daten Strukturen (Array, Map, Set, Tuples)
+// 4. Datenstrukturen (Array, Map, Set, Tuples)
 /////////////////////////////////////////////////
 
 // Array
@@ -344,11 +344,11 @@ a(21)    // Exception
 
 // Map - Speichert Key-Value-Paare
 
-val m = Map("fork" -> "tenedor", "spoon" -> "cuchara", "knife" -> "cuchillo")
+val m = Map("fork" -> "Gabel", "spoon" -> "Löffel", "knife" -> "Messer")
 m("fork")
 m("spoon")
 m("bottle")       // Exception
-val safeM = m.withDefaultValue("no lo se")
+val safeM = m.withDefaultValue("unbekannt")
 safeM("bottle")
 
 // Set - Speichert Unikate, unsortiert (sortiert -> SortedSet)
@@ -369,7 +369,7 @@ s: scala.collection.immutable.Set[Int] = Set(1, 3, 7)
 
 
 // Hier ist der Rückgabewert der Funktion ein Tuple
-// Die Funktion gibt das Ergebnis, so wie den Rest zurück.
+// Die Funktion gibt das Ergebnis sowie den Rest zurück.
 
 val divideInts = (x: Int, y: Int) => (x / y, x % y)
 divideInts(10, 3)
@@ -390,8 +390,8 @@ d._2
 /*
   Bislang waren alle gezeigten Sprachelemente einfache Ausdrücke, welche zwar
   zum Ausprobieren und Lernen in der REPL gut geeignet sind, jedoch in
-  einem Scala file selten alleine zu finden sind.
-  Die einzigen Top-Level Konstrukte in Scala sind nämlich:
+  einer Scala-Datei selten alleine zu finden sind.
+  Die einzigen Top-Level-Konstrukte in Scala sind nämlich:
 
   - Klassen (classes)
   - Objekte (objects)
@@ -406,7 +406,7 @@ d._2
 // Zum Erstellen von Objekten benötigt man eine Klasse, wie in vielen
 // anderen Sprachen auch.
 
-// erzeugt Klasse mit default Konstruktor
+// erzeugt Klasse mit default Konstruktor:
 
 class Hund
 scala> val t = new Hund
@@ -433,7 +433,7 @@ res18: String = Dackel
 
 // Methoden werden mit def geschrieben
 
-def bark = "Woof, woof!"
+def bark = "Wuff, wuff!"
 
 
 // Felder und Methoden können public, protected und private sein
@@ -460,9 +460,9 @@ class Dackel extends Hund {
 // Wird ein Objekt ohne das Schlüsselwort "new" instanziert, wird das sog.
 // "companion object" aufgerufen. Mit dem "object" Schlüsselwort wird so
 // ein Objekt (Typ UND Singleton) erstellt. Damit kann man dann eine Klasse
-// benutzen ohne ein Objekt instanziieren zu müssen.
+// verwenden, ohne ein Objekt instanziieren zu müssen.
 // Ein gültiges companion Objekt einer Klasse ist es aber erst dann, wenn
-// es genauso heisst und in derselben Datei wie die Klasse definiert wurde.
+// es genauso heißt und in derselben Datei wie die Klasse definiert wurde.
 
 object Hund {
   def alleSorten = List("Pitbull", "Dackel", "Retriever")
@@ -470,8 +470,9 @@ object Hund {
 }
 
 // Case classes
-// Fallklassen bzw. Case classes sind Klassen die normale Klassen um extra
-// Funktionalität erweitern. Mit Case Klassen bekommt man ein paar
+// Fallklassen bzw. Case classes sind Klassen, die normale Klassen um
+// zusätzliche Funktionalität erweitern.
+// Mit Case-Klassen bekommt man ein paar
 // Dinge einfach dazu, ohne sich darum kümmern zu müssen. Z.B.
 // ein companion object mit den entsprechenden Methoden,
 // Hilfsmethoden wie toString(), equals() und hashCode() und auch noch
@@ -481,13 +482,13 @@ class Person(val name: String)
 class Hund(val sorte: String, val farbe: String, val halter: Person)
 
 
-// Es genügt das Schlüsselwort case vor die Klasse zu schreiben.
+// Es genügt, das Schlüsselwort case vor die Klasse zu schreiben:
 
 case class Person(name: String)
 case class Hund(sorte: String, farbe: String, halter: Person)
 
 
-// Für neue Instanzen brauch man kein "new"
+// Für neue Instanzen braucht man kein "new":
 
 val dackel = Hund("dackel", "grau", Person("peter"))
 val dogge = Hund("dogge", "grau", Person("peter"))
@@ -511,7 +512,7 @@ val otherGeorge = george.copy(phoneNumber = "9876")
 // Traits
 // Ähnlich wie Java interfaces, definiert man mit traits einen Objekttyp
 // und Methodensignaturen. Scala erlaubt allerdings das teilweise
-// implementieren dieser Methoden. Konstruktorparameter sind nicht erlaubt.
+// Implementieren dieser Methoden. Konstruktorparameter sind nicht erlaubt.
 // Traits können von anderen Traits oder Klassen erben, aber nur von
 // parameterlosen.
 
@@ -543,7 +544,7 @@ res3: Boolean = false
 // mit "with" verwendet werden können.
 
 trait Bellen {
-	def bellen: String = "Woof"
+	def bellen: String = "Wuff"
 }
 trait Hund {
 	def sorte: String
@@ -556,10 +557,10 @@ class Bernhardiner extends Hund with Bellen{
 scala> val b = new Bernhardiner
 b: Bernhardiner = Bernhardiner@7b69c6ba
 scala> b.bellen
-res0: String = Woof
+res0: String = Wuff
 
 /////////////////////////////////////////////////
-// 6. Pattern Matching
+// 6. Mustervergleich (Pattern Matching)
 /////////////////////////////////////////////////
 
 // Pattern matching in Scala ist ein sehr nützliches und wesentlich
@@ -581,7 +582,7 @@ x match {
 val any: Any = ...
 val gleicht = any match {
   case 2 | 3 | 5 => "Zahl"
-  case "woof" => "String"
+  case "wuff" => "String"
   case true | false => "Boolean"
   case 45.35 => "Double"
   case _ => "Unbekannt"
@@ -620,8 +621,8 @@ def matchEverything(obj: Any): String = obj match {
 }
 
 
-// Jedes Objekt mit einer "unapply" Methode kann per Pattern geprüft werden
-// Ganze Funktionen können Patterns sein
+// Jedes Objekt mit einer "unapply" Methode kann per Pattern geprüft werden.
+// Ganze Funktionen können Patterns sein:
 
 val patternFunc: Person => String = {
   case Person("George", number) => s"George's number: $number"
@@ -630,50 +631,50 @@ val patternFunc: Person => String = {
 
 
 /////////////////////////////////////////////////
-// 37. Higher-order functions
+// 7. "Higher-order"-Funktionen
 /////////////////////////////////////////////////
 
-Scala erlaubt, das Methoden und Funktion wiederum Funtionen und Methoden
-als Aufrufparameter oder Return Wert verwenden. Diese Methoden heissen
-higher-order functions
-Es gibt zahlreiche higher-order functions nicht nur für Listen, auch für
-die meisten anderen Collection Typen, sowie andere Klassen in Scala
-Nennenswerte sind:
-"filter", "map", "reduce", "foldLeft"/"foldRight", "exists", "forall"
+// Scala erlaubt, dass Methoden und Funktionen wiederum Funtionen und Methoden
+// als Aufrufparameter oder Rückgabewert verwenden. Diese Methoden heißen
+// higher-order functions.
+// Es gibt zahlreiche higher-order-Funtionen nicht nur für Listen, auch für
+// die meisten anderen Collection-Typen, sowie andere Klassen in Scala.
+// Nennenswerte sind:
+// "filter", "map", "reduce", "foldLeft"/"foldRight", "exists", "forall"
 
-## List
+// List
 
-def isGleichVier(a:Int) = a == 4
+def istGleichVier(a:Int) = a == 4
 val list = List(1, 2, 3, 4)
 val resultExists4 = list.exists(isEqualToFour)
 
 
-## map
+// map
 // map nimmt eine Funktion und führt sie auf jedem Element aus und erzeugt
 // eine neue Liste
 
-// Funktion erwartet ein Int und returned ein Int
+// Funktion erwartet einen Int und gibt einen Int zurück:
 
 val add10: Int => Int = _ + 10
 
 
-// add10 wird auf jedes Element angewendet
+// add10 wird auf jedes Element angewendet:
 
 List(1, 2, 3) map add10 // => List(11, 12, 13)
 
 
-// Anonyme Funktionen können anstatt definierter Funktionen verwendet werden
+// Anonyme Funktionen können anstatt definierter Funktionen verwendet werden:
 
 List(1, 2, 3) map (x => x + 10)
 
 
 // Der Unterstrich wird anstelle eines Parameters einer anonymen Funktion
-// verwendet. Er wird an die Variable gebunden.
+// verwendet. Er wird an die Variable gebunden:
 
 List(1, 2, 3) map (_ + 10)
 
 
-// Wenn der anonyme Block und die Funtion beide EIN Argument erwarten,
+// Wenn der anonyme Block und die Funktion beide EIN Argument erwarten,
 // kann sogar der Unterstrich weggelassen werden.
 
 List("Dom", "Bob", "Natalia") foreach println
@@ -681,7 +682,7 @@ List("Dom", "Bob", "Natalia") foreach println
 
 // filter
 // filter nimmt ein Prädikat (eine Funktion von A -> Boolean) und findet
-// alle Elemente die auf das Prädikat passen
+// alle Elemente, die auf das Prädikat passen:
 
 List(1, 2, 3) filter (_ > 2) // => List(3)
 case class Person(name: String, age: Int)
@@ -693,7 +694,7 @@ List(
 
 // reduce
 // reduce nimmt zwei Elemente und kombiniert sie zu einem Element,
-// und zwar solange bis nur noch ein Element da ist.
+// und zwar so lange, bis nur noch ein Element da ist.
 
 // foreach
 // foreach gibt es für einige Collections
@@ -718,12 +719,12 @@ for { n <- s; nSquared = n * n if nSquared < 10} yield nSquared
 
 // **ACHTUNG:**
 // Implicits sind ein sehr mächtiges Sprachfeature von Scala.
-// Es sehr einfach
+// Es sehr einfach,
 // sie falsch zu benutzen und Anfänger sollten sie mit Vorsicht oder am
-// besten erst dann benutzen, wenn man versteht wie sie funktionieren.
+// besten erst dann benutzen, wenn sie verstehen, wie sie funktionieren.
 // Dieses Tutorial enthält Implicits, da sie in Scala an jeder Stelle
-// vorkommen und man auch mit einer Lib die Implicits benutzt nichts sinnvolles
-// machen kann.
+// vorkommen und man auch mit einer Bibliothek, die Implicits benutzt, sonst
+// nichts sinnvolles machen kann.
 // Hier soll ein Grundverständnis geschaffen werden, wie sie funktionieren.
 
 // Mit dem Schlüsselwort implicit können Methoden, Werte, Funktion, Objekte
@@ -754,10 +755,10 @@ def sendGreetings(toWhom: String)(implicit howMany: Int) =
 sendGreetings("John")(1000)  // => "Hello John, 1000 blessings to you and yours!"
 
 
-// Wird der implicit Parameter jedoch weggelassen, wird ein anderer
-// implicit Wert vom gleichen Typ genommen. Der Compiler sucht im
-// lexikalischen Scope und im companion object nach einem implicit Wert,
-// der vom Typ passt, oder  nach einer implicit Methode mit der er in den
+// Wird der implicit-Parameter jedoch weggelassen, wird ein anderer
+// implicit-Wert vom gleichen Typ genommen. Der Compiler sucht im
+// lexikalischen Scope und im companion object nach einem implicit-Wert,
+// der vom Typ passt, oder nach einer implicit-Methode, mit der er in den
 // geforderten Typ konvertieren kann.
 
 // Hier also: "myImplicitInt", da ein Int gesucht wird
@@ -766,14 +767,14 @@ sendGreetings("Jane")  // => "Hello Jane, 100 blessings to you and yours!"
 
 
 // bzw. "myImplicitFunction"
-// Der String wird erst mit Hilfe der Funktion in Hund konvertiert, und
-// dann wird die Methode aufgerufen
+// Der String wird erst mit Hilfe der Funktion in Hund konvertiert,
+// dann wird die Methode aufgerufen:
 
 "Retriever".sorte // => "Golden Retriever"
 
 
 /////////////////////////////////////////////////
-// 19. Misc
+// 9. Misc
 /////////////////////////////////////////////////
 // Importe
 
@@ -804,7 +805,7 @@ import scala.collection.immutable.{Map => _, Set => _, _}
 
 object Application {
   def main(args: Array[String]): Unit = {
-    // Sachen kommen hierhin
+    // Zeugs hier rein.
   }
 }
 
-- 
cgit v1.2.3


From 5a1816bca9cfe20e76d3584e77d11aa64e1f254a Mon Sep 17 00:00:00 2001
From: Jonas Friedemann Grote <jonas.grote@vico-research.com>
Date: Fri, 8 Sep 2017 13:57:12 +0200
Subject: Fix formatting.

---
 de-de/scala-de.html.markdown | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'de-de')

diff --git a/de-de/scala-de.html.markdown b/de-de/scala-de.html.markdown
index 8b0dc5f0..eb3770e9 100644
--- a/de-de/scala-de.html.markdown
+++ b/de-de/scala-de.html.markdown
@@ -829,11 +829,11 @@ writer.close()
 
 ## Weiterführende Hinweise
 
-// DE
+### DE
 * [Scala Tutorial](https://scalatutorial.wordpress.com)
 * [Scala Tutorial](http://scalatutorial.de)
 
-// EN
+### EN
 * [Scala for the impatient](http://horstmann.com/scala/)
 * [Twitter Scala school](http://twitter.github.io/scala_school/)
 * [The scala documentation](http://docs.scala-lang.org/)
-- 
cgit v1.2.3


From a392fec7345bc1570207ca06ff36fd6feb3771fe Mon Sep 17 00:00:00 2001
From: Jonas Friedemann Grote <jonas.grote@vico-research.com>
Date: Sun, 10 Sep 2017 13:37:06 +0200
Subject: Extend review.

---
 de-de/scala-de.html.markdown | 64 ++++++++++++++++++++++----------------------
 1 file changed, 32 insertions(+), 32 deletions(-)

(limited to 'de-de')

diff --git a/de-de/scala-de.html.markdown b/de-de/scala-de.html.markdown
index eb3770e9..a8344e6a 100644
--- a/de-de/scala-de.html.markdown
+++ b/de-de/scala-de.html.markdown
@@ -40,22 +40,22 @@ Als nächstes beschäftigen wir uns mit ein paar Scala-Grundlagen.
 // 1. Grundlagen
 /////////////////////////////////////////////////
 
-// Einzeilige Kommentare beginnen mit zwei Slashes.
+// Einzeilige Kommentare beginnen mit zwei Schrägstrichen.
 
 /*
-  Mehrzeilige Kommentare starten mit einem Slash-Stern
-  und enden mit einem Stern-Slash.
+  Mehrzeilige Kommentare starten mit Schrägstrich und Stern
+  und enden mit Stern und Schrägstrich.
 */
 
 // Einen Wert und eine zusätzliche neue Zeile ausgeben:
 
-println("Hello world!")
+println("Hallo Welt!")
 println(10)
 
 
 // Einen Wert ohne eine zusätzliche neue Zeile ausgeben:
 
-print("Hello world")
+print("Hallo Welt")
 
 /*
   Variablen werden entweder mit var oder val deklariert.
@@ -128,16 +128,16 @@ Ausdrucks zu speichern. Dieser Wert kann bei Dir anders sein...
 
 // Für Strings gibt es die üblichen Java-Methoden:
 
-"hello world".length
-"hello world".substring(2, 6)
-"hello world".replace("C", "3")
+"Hallo Welt".length
+"Hallo Welt".substring(2, 6)
+"Hallo Welt".replace("C", "3")
 
 
 // Zusätzlich gibt es noch extra Scala-Methoden
 // siehe: scala.collection.immutable.StringOps
 
-"hello world".take(5)
-"hello world".drop(5)
+"Hallo Welt".take(5)
+"Hallo Welt".drop(5)
 
 
 // String-Interpolation: prefix "s":
@@ -296,7 +296,7 @@ i    // i ausgeben, res3: Int = 10
 // Sie läuft sequentiell ab und verändert die loop-Variable.
 // "while" in Scala läuft schneller ab als in Java und die o.g.
 // Kombinatoren und Zusammenlegungen sind einfacher zu verstehen
-// und zu parellelisieren.
+// und zu parallelisieren.
 
 // Ein do while Schleife
 
@@ -331,7 +331,7 @@ val text = if (x == 10) "yeah" else "nope"
 
 
 /////////////////////////////////////////////////
-// 4. Datenstrukturen (Array, Map, Set, Tuples)
+// 4. Datenstrukturen (Array, Map, Set, Tupel)
 /////////////////////////////////////////////////
 
 // Array
@@ -359,8 +359,8 @@ s(1) //true
 val s = Set(1,1,3,3,7)
 s: scala.collection.immutable.Set[Int] = Set(1, 3, 7)
 
-// Tuple - Speichert beliebige Daten und "verbindet" sie miteinander
-// Ein Tuple ist keine Collection.
+// Tupel - Speichert beliebige Daten und "verbindet" sie miteinander
+// Ein Tupel ist keine Collection.
 
 (1, 2)
 (4, 3, 2)
@@ -368,14 +368,14 @@ s: scala.collection.immutable.Set[Int] = Set(1, 3, 7)
 (a, 2, "three")
 
 
-// Hier ist der Rückgabewert der Funktion ein Tuple
+// Hier ist der Rückgabewert der Funktion ein Tupel
 // Die Funktion gibt das Ergebnis sowie den Rest zurück.
 
 val divideInts = (x: Int, y: Int) => (x / y, x % y)
 divideInts(10, 3)
 
 
-// Um die Elemente eines Tuples anzusprechen, benutzt man diese
+// Um die Elemente eines Tupels anzusprechen, benutzt man diese
 // Notation: _._n wobei n der index des Elements ist (Index startet bei 1)
 
 val d = divideInts(10, 3)
@@ -603,21 +603,21 @@ def matchPerson(person: Person): String = person match {
 val email = "(.*)@(.*)".r  // regex
 def matchEverything(obj: Any): String = obj match {
   // Werte:
-  case "Hello world" => "Got the string Hello world"
+  case "Hallo Welt" => "string Hallo Welt gefunden"
   // Typen:
-  case x: Double => "Got a Double: " + x
-  // Conditions:
-  case x: Int if x > 10000 => "Got a pretty big number!"
-  // Case Classes:
-  case Person(name, number) => s"Got contact info for $name!"
+  case x: Double => "Double gefunden: " + x
+  // Bedingungen:
+  case x: Int if x > 10000 => "Ziemlich große Zahl gefunden!"
+  // Case-Klassen:
+  case Person(name, number) => s"Kontaktinformationen für $name gefunden!"
   // RegEx:
-  case email(name, domain) => s"Got email address $name@$domain"
-  // Tuples:
-  case (a: Int, b: Double, c: String) => s"Got a tuple: $a, $b, $c"
+  case email(name, domain) => s"E-Mail-Adresse $name@$domain gefunden"
+  // Tupel:
+  case (a: Int, b: Double, c: String) => s"Tupel gefunden: $a, $b, $c"
   // Strukturen:
-  case List(1, b, c) => s"Got a list with three elements and starts with 1: 1, $b, $c"
-  // Patterns kann man ineinander schachteln:
-  case List(List((1, 2, "YAY"))) => "Got a list of list of tuple"
+  case List(1, b, c) => s"Liste aus drei Elementen gefunden, startend mit 1: 1, $b, $c"
+  // Pattern kann man ineinander schachteln:
+  case List(List((1, 2, "YAY"))) => "Liste von Tupeln gefunden"
 }
 
 
@@ -747,12 +747,12 @@ myImplicitFunction("Pitbull").sorte // => "Golden Pitbull"
 // Diese Funktion hat zwei Parameter: einen normalen und einen implicit
 
 def sendGreetings(toWhom: String)(implicit howMany: Int) =
-  s"Hello $toWhom, $howMany blessings to you and yours!"
+  s"Hallo $toWhom, $howMany Segenswünsche für Sie und Ihre Angehörigen!"
 
 
 // Werden beide Parameter gefüllt, verhält sich die Funktion wie erwartet
 
-sendGreetings("John")(1000)  // => "Hello John, 1000 blessings to you and yours!"
+sendGreetings("John")(1000)  // => "Hallo John, 1000 Segenswünsche für Sie und Ihre Angehörigen!"
 
 
 // Wird der implicit-Parameter jedoch weggelassen, wird ein anderer
@@ -763,7 +763,7 @@ sendGreetings("John")(1000)  // => "Hello John, 1000 blessings to you and yours!
 
 // Hier also: "myImplicitInt", da ein Int gesucht wird
 
-sendGreetings("Jane")  // => "Hello Jane, 100 blessings to you and yours!"
+sendGreetings("Jane")  // => "Hallo Jane, 100 Segenswünsche für Sie und Ihre Angehörigen!"
 
 
 // bzw. "myImplicitFunction"
@@ -774,7 +774,7 @@ sendGreetings("Jane")  // => "Hello Jane, 100 blessings to you and yours!"
 
 
 /////////////////////////////////////////////////
-// 9. Misc
+// 9. Sonstiges
 /////////////////////////////////////////////////
 // Importe
 
-- 
cgit v1.2.3