Grundkurs funktionale Programmierung mit Scala

1 - Inhaltsverzeichnis [Seite 8]
2 - Vorwort [Seite 16]
3 - I Abenteuer Lambda [Seite 18]
3.1 - 1 Mehr denken, weniger tippen [Seite 20]
3.1.1 - 1.1 Sag, was du willst! [Seite 20]
3.1.2 - 1.2 Der alte Weg [Seite 21]
3.1.3 - 1.3 Abstraktion der Hardware [Seite 22]
3.1.4 - 1.4 Was ist funktionale Programmierung? [Seite 23]
3.1.5 - 1.5 Funktionen - Unsere Bausteine [Seite 23]
3.1.5.1 - 1.5.1 Was ist eine Funktion? [Seite 23]
3.1.5.2 - 1.5.2 Was steckt in einer Funktion? [Seite 24]
3.1.5.3 - 1.5.3 Eigenschaften von Funktionen [Seite 25]
3.1.6 - 1.6 Die referentielle Transparenz [Seite 28]
3.1.7 - 1.7 Das wirkliche Leben [Seite 29]
3.2 - 2 Ein Hauch von Babylon [Seite 32]
3.2.1 - 2.1 Lisp - Die Mutter aller funktionalen Sprachen [Seite 32]
3.2.1.1 - 2.1.1 Listen - Der Stoff, aus dem Lisp gemacht ist [Seite 33]
3.2.1.2 - 2.1.2 Operatoren in Lisp [Seite 34]
3.2.1.3 - 2.1.3 Lambda-Ausdrücke [Seite 35]
3.2.1.4 - 2.1.4 Mythos Lisp [Seite 37]
3.2.2 - 2.2 ML - Der Pionier [Seite 38]
3.2.2.1 - 2.2.1 Typableitung - Der Compiler erkennt den Typ [Seite 39]
3.2.2.2 - 2.2.2 Muster und Ausdrücke [Seite 39]
3.2.2.3 - 2.2.3 Generische Funktionen und Datentypen [Seite 41]
3.2.3 - 2.3 Haskell - Funktionale Programmierung in Reinform [Seite 42]
3.2.3.1 - 2.3.1 Haskell - Ein fauler Hund [Seite 43]
3.2.4 - 2.4 Wann ist eine Sprache funktional? [Seite 45]
3.2.5 - 2.5 Und die Performance? [Seite 45]
3.2.6 - 2.6 Welche Sprache darf's denn sein? [Seite 46]
3.2.6.1 - 2.6.1 Java [Seite 46]
3.2.6.2 - 2.6.2 Scala [Seite 47]
3.2.7 - 2.7 Aufgaben [Seite 48]
4 - II Die funktionale Seite von Java [Seite 50]
4.1 - 3 Rekursion [Seite 52]
4.1.1 - 3.1 Eine Schleife - was ist das eigentlich? [Seite 52]
4.1.2 - 3.2 Die Rekursion - das unbekannte Wesen [Seite 53]
4.1.3 - 3.3 Ist Rekursion praxistauglich? [Seite 54]
4.1.4 - 3.4 Wie werden rekursive Funktionen verarbeitet? [Seite 55]
4.1.5 - 3.5 Endrekursion, die schnelle Rekursion [Seite 57]
4.1.6 - 3.6 Eine einfache Formel und ihre schwerwiegenden Folgen [Seite 60]
4.1.7 - 3.7 Aufgaben [Seite 63]
4.2 - 4 Alles bleibt, wie es ist [Seite 66]
4.2.1 - 4.1 Konsistenz [Seite 66]
4.2.2 - 4.2 Nichts ist beständiger als der Wandel [Seite 67]
4.2.3 - 4.3 Versteckte Daten sind gute Daten [Seite 68]
4.2.4 - 4.4 Invarianten - darauf ist Verlass [Seite 69]
4.2.5 - 4.5 Ein Beispiel [Seite 71]
4.2.6 - 4.6 Die Methode equals [Seite 72]
4.2.7 - 4.7 Sichere Ergebnisse mit defensiven Kopien [Seite 72]
4.2.8 - 4.8 Konkurrierende Zugriffe [Seite 74]
4.2.9 - 4.9 Geänderte Hash-Codes [Seite 75]
4.2.10 - 4.10 Unveränderbare Klassen [Seite 76]
4.2.11 - 4.11 Performance [Seite 77]
4.2.12 - 4.12 Unveränderbare Klassen in der Java-API [Seite 78]
4.2.13 - 4.13 Aufgaben [Seite 79]
4.3 - 5 Funktionen höherer Ordnung [Seite 80]
4.3.1 - 5.1 Arrays sortieren leicht gemacht [Seite 80]
4.3.2 - 5.2 Eine flexiblere Lösung [Seite 82]
4.3.3 - 5.3 Funktionen als Ergebnisse von Funktionen [Seite 85]
4.3.4 - 5.4 Aufgaben [Seite 88]
4.4 - 6 Unveränderbare Listen [Seite 90]
4.4.1 - 6.1 Arrays raus! [Seite 90]
4.4.2 - 6.2 Verkettete Listen - Vom Nobody zum Star [Seite 91]
4.4.3 - 6.3 Nützliche Methoden für die Arbeit mit Listen [Seite 93]
4.4.4 - 6.4 Das schwer erreichbare Listenende [Seite 94]
4.4.5 - 6.5 Die Faltung - eine universelle Funktion [Seite 95]
4.4.6 - 6.6 Eine Leihgabe aus der imperativen Programmierung [Seite 98]
4.4.7 - 6.7 Aufgaben [Seite 100]
4.5 - 7 Anfragen an Listen [Seite 102]
4.5.1 - 7.1 Auswahlen aus Listen [Seite 103]
4.5.2 - 7.2 Listenelemente abbilden [Seite 104]
4.5.3 - 7.3 Quicksort [Seite 105]
4.5.4 - 7.4 Primzahlen [Seite 107]
4.5.5 - 7.5 Verknüpfungen von Listen [Seite 108]
4.5.6 - 7.6 Aufgaben [Seite 110]
5 - III Scala [Seite 112]
5.1 - 8 Die Scala-Entwicklungsumgebung [Seite 114]
5.1.1 - 8.1 Ohne Java geht nichts [Seite 114]
5.1.2 - 8.2 Installation und erste Schritte [Seite 115]
5.1.3 - 8.3 Scala-Skripts [Seite 115]
5.1.4 - 8.4 Eigene Typen mit Scala-Klassen [Seite 116]
5.1.5 - 8.5 Noch ein Compiler [Seite 117]
5.1.6 - 8.6 Der Scala-Bazar [Seite 118]
5.1.7 - 8.7 Aufgaben [Seite 119]
5.2 - 9 Ausdrücke in Scala [Seite 122]
5.2.1 - 9.1 Erste Eindrücke mit einfachen Ausdrücken [Seite 122]
5.2.2 - 9.2 Konstante [Seite 123]
5.2.3 - 9.3 Variable [Seite 125]
5.2.4 - 9.4 Alle kennen Predef [Seite 125]
5.2.5 - 9.5 Kontrollstrukturen [Seite 126]
5.2.6 - 9.6 Importe [Seite 127]
5.2.7 - 9.7 Aufgaben [Seite 127]
5.3 - 10 Scala-Typsystem [Seite 130]
5.3.1 - 10.1 In Scala gibt es keine primitiven Typen [Seite 130]
5.3.2 - 10.2 Alles ist ein Objekt [Seite 131]
5.3.3 - 10.3 Objekte vergleichen [Seite 132]
5.3.4 - 10.4 Werte- und Referenztypen [Seite 133]
5.3.5 - 10.5 Literale und Typumwandlungen [Seite 133]
5.3.6 - 10.6 Der Typ Unit [Seite 134]
5.3.7 - 10.7 Der Typ Null [Seite 134]
5.3.8 - 10.8 Der Typ Nothing [Seite 135]
5.3.9 - 10.9 Aufgaben [Seite 136]
5.4 - 11 Methoden in Scala [Seite 138]
5.4.1 - 11.1 Jede Methode hat einen Typ [Seite 138]
5.4.2 - 11.2 Generische Methoden [Seite 139]
5.4.3 - 11.3 Konstante als Grenzfall von Methoden [Seite 139]
5.4.4 - 11.4 Was steht in einer Methode? [Seite 140]
5.4.5 - 11.5 Methoden ohne Rückgabewert [Seite 142]
5.4.6 - 11.6 Methoden in Methoden [Seite 142]
5.4.7 - 11.7 Methoden für beliebig viele Argumente [Seite 143]
5.4.8 - 11.8 Endrekursion [Seite 144]
5.4.9 - 11.9 Aufgaben [Seite 146]
5.5 - 12 Funktionen in Scala [Seite 148]
5.5.1 - 12.1 Die Definition einer Funktion [Seite 148]
5.5.2 - 12.2 Funktionen sind auch Objekte [Seite 150]
5.5.3 - 12.3 Die partielle Anwendung einer Funktion [Seite 151]
5.5.4 - 12.4 Eine scharfe Sache: Das Curry-Prinzip [Seite 153]
5.5.5 - 12.5 Funktionen höherer Ordnung [Seite 155]
5.5.6 - 12.6 Aufgaben [Seite 157]
5.6 - 13 Tupel [Seite 160]
5.6.1 - 13.1 Eigenschaften von Tupeln [Seite 161]
5.6.2 - 13.2 Die Tupel-Klassen [Seite 162]
5.6.3 - 13.3 Mustererkennung für Tupel [Seite 163]
5.6.4 - 13.4 Aufgaben [Seite 164]
5.7 - 14 Klassen und Vererbung in Scala [Seite 166]
5.7.1 - 14.1 Klassendefinitionen in Scala [Seite 166]
5.7.1.1 - 14.1.1 Ein alter Bekannter zum Einstieg [Seite 166]
5.7.1.2 - 14.1.2 Konstruktoren [Seite 167]
5.7.1.3 - 14.1.3 Attribute und parameterfreie Methoden [Seite 169]
5.7.1.4 - 14.1.4 Mehrere Fliegen mit einer Klappe schlagen [Seite 170]
5.7.1.5 - 14.1.5 Was bedeutet "rechtsassoziativ"? [Seite 171]
5.7.2 - 14.2 Vererbung [Seite 171]
5.7.2.1 - 14.2.1 Methoden überschreiben [Seite 171]
5.7.2.2 - 14.2.2 Konstruktorverkettung [Seite 173]
5.7.2.3 - 14.2.3 Polymorphie [Seite 174]
5.7.2.4 - 14.2.4 Abstrakte Klassen [Seite 175]
5.7.3 - 14.3 Aufgaben [Seite 176]
5.8 - 15 Singletons: Objekte können einsam sein [Seite 178]
5.8.1 - 15.1 Es kann nur einen geben [Seite 179]
5.8.2 - 15.2 Statische Mitglieder waren gestern [Seite 180]
5.8.3 - 15.3 Begleiter [Seite 180]
5.8.4 - 15.4 Singletons zur Objektverwaltung [Seite 182]
5.8.5 - 15.5 Singletons importieren [Seite 182]
5.8.6 - 15.6 Aufgaben [Seite 183]
5.9 - 16 Mustererkennung [Seite 184]
5.9.1 - 16.1 Muster in Java [Seite 185]
5.9.2 - 16.2 Einfache Muster in Scala [Seite 186]
5.9.3 - 16.3 Muster für Tupel [Seite 187]
5.9.4 - 16.4 Welche Muster gibt es? [Seite 188]
5.9.5 - 16.5 Muster für Typen [Seite 189]
5.9.6 - 16.6 Muster in Funktionen [Seite 191]
5.9.7 - 16.7 Partielle Funktionen [Seite 191]
5.9.8 - 16.8 Exceptions und Mustererkennung [Seite 192]
5.9.9 - 16.9 Aufgaben [Seite 193]
5.10 - 17 Extraktoren und Case-Typen [Seite 194]
5.10.1 - 17.1 Besser als null: Der Typ Option [Seite 195]
5.10.2 - 17.2 Extraktormuster [Seite 195]
5.10.3 - 17.3 Optionale Attribute [Seite 196]
5.10.4 - 17.4 Extraktoren sind universelle Inspektoren [Seite 197]
5.10.5 - 17.5 Lesbarer Code mit apply [Seite 199]
5.10.6 - 17.6 Variable Extraktoren [Seite 200]
5.10.7 - 17.7 Alles frei Haus mit Case-Typen [Seite 200]
5.10.8 - 17.8 Aufgaben [Seite 204]
5.11 - 18 Listen [Seite 206]
5.11.1 - 18.1 Die leere Liste [Seite 206]
5.11.2 - 18.2 Listen erzeugen [Seite 207]
5.11.3 - 18.3 Einfache Methoden für Listen [Seite 207]
5.11.4 - 18.4 Listenmuster [Seite 208]
5.11.5 - 18.5 Weitere einfache Methoden [Seite 209]
5.11.6 - 18.6 Mengenoperationen [Seite 211]
5.11.7 - 18.7 Das Begleitobjekt [Seite 212]
5.11.8 - 18.8 Methoden höherer Ordnung für Listen [Seite 213]
5.11.8.1 - 18.8.1 Beispiel: Quicksort [Seite 214]
5.11.8.2 - 18.8.2 Die Faltung [Seite 215]
5.11.9 - 18.9 Das Springerproblem [Seite 217]
5.11.10 - 18.10 Aufgaben [Seite 219]
5.12 - 19 Scala kann auch faul sein [Seite 220]
5.12.1 - 19.1 Die Initialisierung kann warten [Seite 220]
5.12.2 - 19.2 Faule Parameter mit Call-By-Name [Seite 222]
5.12.3 - 19.3 Streams: Daten bei Bedarf [Seite 223]
5.12.4 - 19.4 Unendliche Streams [Seite 225]
5.12.5 - 19.5 Aufgaben [Seite 226]
5.13 - 20 Es müssen nicht immer Listen sein [Seite 228]
5.13.1 - 20.1 Mengen [Seite 228]
5.13.2 - 20.2 Der Typ Set [Seite 230]
5.13.3 - 20.3 Der Typ Map [Seite 231]
5.13.4 - 20.4 Collections in anderen Geschmacksrichtungen [Seite 235]
5.13.5 - 20.5 Aufgaben [Seite 236]
5.14 - 21 Fast wie zu Hause: for-Ausdrücke [Seite 238]
5.14.1 - 21.1 Eine nicht ganz so funktionale Methode höherer Ordnung [Seite 238]
5.14.2 - 21.2 Komplexere for-Ausdrücke [Seite 239]
5.14.3 - 21.3 for-Ausdrücke mit filter und map [Seite 239]
5.14.4 - 21.4 Mehr Übersicht mit flatMap [Seite 240]
5.14.5 - 21.5 for-Ausdrücke sind keine Schleifen [Seite 241]
5.14.6 - 21.6 for-Ausdrücke für eigene Typen [Seite 242]
5.14.7 - 21.7 Aufgaben [Seite 243]
6 - IV Scala kann mehr [Seite 244]
6.1 - 22 Veränderbare Daten [Seite 246]
6.1.1 - 22.1 Variable [Seite 246]
6.1.2 - 22.2 Veränderbare Attribute [Seite 247]
6.1.3 - 22.3 Die Rückkehr der Arrays [Seite 249]
6.1.4 - 22.4 Aufgaben [Seite 250]
6.2 - 23 Traits [Seite 252]
6.2.1 - 23.1 Traits und Java-Interfaces [Seite 253]
6.2.2 - 23.2 Konkrete Methoden [Seite 253]
6.2.3 - 23.3 Mehrfachvererbung [Seite 255]
6.2.4 - 23.4 Aufgaben [Seite 256]
6.3 - 24 Varianz [Seite 258]
6.3.1 - 24.1 Kovarianz von Java-Arrays [Seite 258]
6.3.2 - 24.2 Kovarianz von generischen Java-Typen [Seite 259]
6.3.3 - 24.3 Mehr Kovarianz in Java [Seite 260]
6.3.4 - 24.4 Kontravarianz in Java [Seite 261]
6.3.5 - 24.5 Varianz in Scala [Seite 261]
6.4 - 25 Pakete und Sichtbarkeit [Seite 266]
6.4.1 - 25.1 Pakete in Scala [Seite 266]
6.4.2 - 25.2 Sichtbarkeit in Scala [Seite 267]
6.4.3 - 25.3 Privater als privat [Seite 269]
6.5 - 26 Typumwandlung [Seite 272]
6.5.1 - 26.1 Implizite Methoden für implizite Casts [Seite 272]
6.5.2 - 26.2 Wozu noch explizite Casts? [Seite 274]
6.5.3 - 26.3 Angereicherte Typen [Seite 274]
6.5.4 - 26.4 Pimp Your Library! [Seite 275]
6.5.5 - 26.5 Sprachfeatures mit impliziten Casts umsetzen [Seite 276]
6.5.6 - 26.6 Aufgaben [Seite 276]
6.6 - 27 Parallele Programmierung mit Aktoren [Seite 278]
6.6.1 - 27.1 Viele Köche verderben den Brei [Seite 279]
6.6.2 - 27.2 Parallele Programmierung mal anders [Seite 279]
6.6.3 - 27.3 Erste Versuche mit Aktoren [Seite 281]
6.6.4 - 27.4 Der Typ Actor [Seite 282]
6.6.5 - 27.5 Die Actor-Fabrik [Seite 283]
6.6.6 - 27.6 Einfache Standardprobleme und ihre Lösung [Seite 284]
6.6.7 - 27.7 Aktoren können antworten [Seite 285]
6.6.8 - 27.8 Producer-Consumer-Probleme [Seite 286]
6.6.9 - 27.9 Blockierende Stacks [Seite 288]
6.6.10 - 27.10 Deadlocks - Nichts geht mehr [Seite 289]
6.6.11 - 27.11 Aufgaben [Seite 293]
7 - Literaturverzeichnis [Seite 293]
8 - Stichwortverzeichnis [Seite 296]