Piepmeyer Grundkurs funktionale Programmierung mit Scala
1. Auflage 2010
ISBN: 978-3-446-42416-6
Verlag: Hanser, Carl
Format: PDF
Kopierschutz: Adobe DRM (»Systemvoraussetzungen)
E-Book, Deutsch, 306 Seiten
ISBN: 978-3-446-42416-6
Verlag: Hanser, Carl
Format: PDF
Kopierschutz: Adobe DRM (»Systemvoraussetzungen)
FUNKTIONALE PROGRAMMIERUNG REVISITED
- Steigen Sie in die funktionale Programmierung auf der Basis Ihrer Java-Kenntnisse ein.
-Lernen Sie die Programmiersprache Scala und ihre Vorzüge kennen.
-Jedes Kapitel enthält Übungsaufgaben.
-Auf der Website zum Buch: Die Lösungen der Übungsaufgaben und ein Foliensatz für Dozenten
GRUNDKURS FUNKTIONALE PROGRAMMIERUNG MIT SCALA
Funktionale Programmierung erlebt eine Renaissance - viele Programmiersprachen nutzen inzwischen Ideen der funktionalen Programmierung, etwa zur Parallelisierung von Software. Und es gibt jetzt auch eine neue, moderne funktionale Programmiersprache: Scala. Sie ist mit Java kompatibel und genießt nicht zuletzt deshalb große Aufmerksamkeit. Ausreichend Gründe also, um sich mit den Grundlagen der funktionalen Programmierung auseinanderzusetzen.
Dieser Grundkurs führt Sie in die funktionale Programmierung ein. Sie lernen die Besonderheiten dieses Programmierparadigmas zunächst an Java kennen. Im nächsten Schritt steigen Sie auf die Sprache Scala um. Am Beispiel von Scala erklärt Ihnen der Autor die typischen Elemente funktionaler Sprachen und zeigt, wie Sie sie in der Praxis anwenden können.
"Das ist doch nur was für Spinner." Diese Meinung hat man lange Zeit explizit oder zwischen den Zeilen gehört, wenn man in Projekten den Einsatz funktionaler Programmierung vorgeschlagen hat. Die Zeiten ändern sich aber: Nach über 50 Jahren hat diese Art der Softwareentwicklung die Hörsäle verlassen und gewinnt im Alltag des Entwicklers zunehmend an Bedeutung. In diesem Buch werden Sie die funktionale Programmierung und die Sprache Scala kennenlernen. Freuen Sie sich auf das Abenteuer Lambda!
Lothar Piepmeyer
Autoren/Hrsg.
Weitere Infos & Material
1;Inhaltsverzeichnis;8
2;Vorwort;16
3;I Abenteuer Lambda;18
3.1;1 Mehr denken, weniger tippen;20
3.1.1;1.1 Sag, was du willst!;20
3.1.2;1.2 Der alte Weg;21
3.1.3;1.3 Abstraktion der Hardware;22
3.1.4;1.4 Was ist funktionale Programmierung?;23
3.1.5;1.5 Funktionen – Unsere Bausteine;23
3.1.5.1;1.5.1 Was ist eine Funktion?;23
3.1.5.2;1.5.2 Was steckt in einer Funktion?;24
3.1.5.3;1.5.3 Eigenschaften von Funktionen;25
3.1.6;1.6 Die referentielle Transparenz;28
3.1.7;1.7 Das wirkliche Leben;29
3.2;2 Ein Hauch von Babylon;32
3.2.1;2.1 Lisp – Die Mutter aller funktionalen Sprachen;32
3.2.1.1;2.1.1 Listen – Der Stoff, aus dem Lisp gemacht ist;33
3.2.1.2;2.1.2 Operatoren in Lisp;34
3.2.1.3;2.1.3 Lambda-Ausdrücke;35
3.2.1.4;2.1.4 Mythos Lisp;37
3.2.2;2.2 ML – Der Pionier;38
3.2.2.1;2.2.1 Typableitung – Der Compiler erkennt den Typ;39
3.2.2.2;2.2.2 Muster und Ausdrücke;39
3.2.2.3;2.2.3 Generische Funktionen und Datentypen;41
3.2.3;2.3 Haskell – Funktionale Programmierung in Reinform;42
3.2.3.1;2.3.1 Haskell – Ein fauler Hund;43
3.2.4;2.4 Wann ist eine Sprache funktional?;45
3.2.5;2.5 Und die Performance?;45
3.2.6;2.6 Welche Sprache darf's denn sein?;46
3.2.6.1;2.6.1 Java;46
3.2.6.2;2.6.2 Scala;47
3.2.7;2.7 Aufgaben;48
4;II Die funktionale Seite von Java;50
4.1;3 Rekursion;52
4.1.1;3.1 Eine Schleife – was ist das eigentlich?;52
4.1.2;3.2 Die Rekursion – das unbekannte Wesen;53
4.1.3;3.3 Ist Rekursion praxistauglich?;54
4.1.4;3.4 Wie werden rekursive Funktionen verarbeitet?;55
4.1.5;3.5 Endrekursion, die schnelle Rekursion;57
4.1.6;3.6 Eine einfache Formel und ihre schwerwiegenden Folgen;60
4.1.7;3.7 Aufgaben;63
4.2;4 Alles bleibt, wie es ist;66
4.2.1;4.1 Konsistenz;66
4.2.2;4.2 Nichts ist beständiger als der Wandel;67
4.2.3;4.3 Versteckte Daten sind gute Daten;68
4.2.4;4.4 Invarianten – darauf ist Verlass;69
4.2.5;4.5 Ein Beispiel;71
4.2.6;4.6 Die Methode equals;72
4.2.7;4.7 Sichere Ergebnisse mit defensiven Kopien;72
4.2.8;4.8 Konkurrierende Zugriffe;74
4.2.9;4.9 Geänderte Hash-Codes;75
4.2.10;4.10 Unveränderbare Klassen;76
4.2.11;4.11 Performance;77
4.2.12;4.12 Unveränderbare Klassen in der Java-API;78
4.2.13;4.13 Aufgaben;79
4.3;5 Funktionen höherer Ordnung;80
4.3.1;5.1 Arrays sortieren leicht gemacht;80
4.3.2;5.2 Eine flexiblere Lösung;82
4.3.3;5.3 Funktionen als Ergebnisse von Funktionen;85
4.3.4;5.4 Aufgaben;88
4.4;6 Unveränderbare Listen;90
4.4.1;6.1 Arrays raus!;90
4.4.2;6.2 Verkettete Listen – Vom Nobody zum Star;91
4.4.3;6.3 Nützliche Methoden für die Arbeit mit Listen;93
4.4.4;6.4 Das schwer erreichbare Listenende;94
4.4.5;6.5 Die Faltung – eine universelle Funktion;95
4.4.6;6.6 Eine Leihgabe aus der imperativen Programmierung;98
4.4.7;6.7 Aufgaben;100
4.5;7 Anfragen an Listen;102
4.5.1;7.1 Auswahlen aus Listen;103
4.5.2;7.2 Listenelemente abbilden;104
4.5.3;7.3 Quicksort;105
4.5.4;7.4 Primzahlen;107
4.5.5;7.5 Verknüpfungen von Listen;108
4.5.6;7.6 Aufgaben;110
5;III Scala;112
5.1;8 Die Scala-Entwicklungsumgebung;114
5.1.1;8.1 Ohne Java geht nichts;114
5.1.2;8.2 Installation und erste Schritte;115
5.1.3;8.3 Scala-Skripts;115
5.1.4;8.4 Eigene Typen mit Scala-Klassen;116
5.1.5;8.5 Noch ein Compiler;117
5.1.6;8.6 Der Scala-Bazar;118
5.1.7;8.7 Aufgaben;119
5.2;9 Ausdrücke in Scala;122
5.2.1;9.1 Erste Eindrücke mit einfachen Ausdrücken;122
5.2.2;9.2 Konstante;123
5.2.3;9.3 Variable;125
5.2.4;9.4 Alle kennen Predef;125
5.2.5;9.5 Kontrollstrukturen;126
5.2.6;9.6 Importe;127
5.2.7;9.7 Aufgaben;127
5.3;10 Scala-Typsystem;130
5.3.1;10.1 In Scala gibt es keine primitiven Typen;130
5.3.2;10.2 Alles ist ein Objekt;131
5.3.3;10.3 Objekte vergleichen;132
5.3.4;10.4 Werte- und Referenztypen;133
5.3.5;10.5 Literale und Typumwandlungen;133
5.3.6;10.6 Der Typ Unit;134
5.3.7;10.7 Der Typ Null;134
5.3.8;10.8 Der Typ Nothing;135
5.3.9;10.9 Aufgaben;136
5.4;11 Methoden in Scala;138
5.4.1;11.1 Jede Methode hat einen Typ;138
5.4.2;11.2 Generische Methoden;139
5.4.3;11.3 Konstante als Grenzfall von Methoden;139
5.4.4;11.4 Was steht in einer Methode?;140
5.4.5;11.5 Methoden ohne Rückgabewert;142
5.4.6;11.6 Methoden in Methoden;142
5.4.7;11.7 Methoden für beliebig viele Argumente;143
5.4.8;11.8 Endrekursion;144
5.4.9;11.9 Aufgaben;146
5.5;12 Funktionen in Scala;148
5.5.1;12.1 Die Definition einer Funktion;148
5.5.2;12.2 Funktionen sind auch Objekte;150
5.5.3;12.3 Die partielle Anwendung einer Funktion;151
5.5.4;12.4 Eine scharfe Sache: Das Curry-Prinzip;153
5.5.5;12.5 Funktionen höherer Ordnung;155
5.5.6;12.6 Aufgaben;157
5.6;13 Tupel;160
5.6.1;13.1 Eigenschaften von Tupeln;161
5.6.2;13.2 Die Tupel-Klassen;162
5.6.3;13.3 Mustererkennung für Tupel;163
5.6.4;13.4 Aufgaben;164
5.7;14 Klassen und Vererbung in Scala;166
5.7.1;14.1 Klassendefinitionen in Scala;166
5.7.1.1;14.1.1 Ein alter Bekannter zum Einstieg;166
5.7.1.2;14.1.2 Konstruktoren;167
5.7.1.3;14.1.3 Attribute und parameterfreie Methoden;169
5.7.1.4;14.1.4 Mehrere Fliegen mit einer Klappe schlagen;170
5.7.1.5;14.1.5 Was bedeutet „rechtsassoziativ“?;171
5.7.2;14.2 Vererbung;171
5.7.2.1;14.2.1 Methoden überschreiben;171
5.7.2.2;14.2.2 Konstruktorverkettung;173
5.7.2.3;14.2.3 Polymorphie;174
5.7.2.4;14.2.4 Abstrakte Klassen;175
5.7.3;14.3 Aufgaben;176
5.8;15 Singletons: Objekte können einsam sein;178
5.8.1;15.1 Es kann nur einen geben;179
5.8.2;15.2 Statische Mitglieder waren gestern;180
5.8.3;15.3 Begleiter;180
5.8.4;15.4 Singletons zur Objektverwaltung;182
5.8.5;15.5 Singletons importieren;182
5.8.6;15.6 Aufgaben;183
5.9;16 Mustererkennung;184
5.9.1;16.1 Muster in Java;185
5.9.2;16.2 Einfache Muster in Scala;186
5.9.3;16.3 Muster für Tupel;187
5.9.4;16.4 Welche Muster gibt es?;188
5.9.5;16.5 Muster für Typen;189
5.9.6;16.6 Muster in Funktionen;191
5.9.7;16.7 Partielle Funktionen;191
5.9.8;16.8 Exceptions und Mustererkennung;192
5.9.9;16.9 Aufgaben;193
5.10;17 Extraktoren und Case-Typen;194
5.10.1;17.1 Besser als null: Der Typ Option;195
5.10.2;17.2 Extraktormuster;195
5.10.3;17.3 Optionale Attribute;196
5.10.4;17.4 Extraktoren sind universelle Inspektoren;197
5.10.5;17.5 Lesbarer Code mit apply;199
5.10.6;17.6 Variable Extraktoren;200
5.10.7;17.7 Alles frei Haus mit Case-Typen;200
5.10.8;17.8 Aufgaben;204
5.11;18 Listen;206
5.11.1;18.1 Die leere Liste;206
5.11.2;18.2 Listen erzeugen;207
5.11.3;18.3 Einfache Methoden für Listen;207
5.11.4;18.4 Listenmuster;208
5.11.5;18.5 Weitere einfache Methoden;209
5.11.6;18.6 Mengenoperationen;211
5.11.7;18.7 Das Begleitobjekt;212
5.11.8;18.8 Methoden höherer Ordnung für Listen;213
5.11.8.1;18.8.1 Beispiel: Quicksort;214
5.11.8.2;18.8.2 Die Faltung;215
5.11.9;18.9 Das Springerproblem;217
5.11.10;18.10 Aufgaben;219
5.12;19 Scala kann auch faul sein;220
5.12.1;19.1 Die Initialisierung kann warten;220
5.12.2;19.2 Faule Parameter mit Call-By-Name;222
5.12.3;19.3 Streams: Daten bei Bedarf;223
5.12.4;19.4 Unendliche Streams;225
5.12.5;19.5 Aufgaben;226
5.13;20 Es müssen nicht immer Listen sein;228
5.13.1;20.1 Mengen;228
5.13.2;20.2 Der Typ Set;230
5.13.3;20.3 Der Typ Map;231
5.13.4;20.4 Collections in anderen Geschmacksrichtungen;235
5.13.5;20.5 Aufgaben;236
5.14;21 Fast wie zu Hause: for-Ausdrücke;238
5.14.1;21.1 Eine nicht ganz so funktionale Methode höherer Ordnung;238
5.14.2;21.2 Komplexere for-Ausdrücke;239
5.14.3;21.3 for-Ausdrücke mit filter und map;239
5.14.4;21.4 Mehr Übersicht mit flatMap;240
5.14.5;21.5 for-Ausdrücke sind keine Schleifen;241
5.14.6;21.6 for-Ausdrücke für eigene Typen;242
5.14.7;21.7 Aufgaben;243
6;IV Scala kann mehr;244
6.1;22 Veränderbare Daten;246
6.1.1;22.1 Variable;246
6.1.2;22.2 Veränderbare Attribute;247
6.1.3;22.3 Die Rückkehr der Arrays;249
6.1.4;22.4 Aufgaben;250
6.2;23 Traits;252
6.2.1;23.1 Traits und Java-Interfaces;253
6.2.2;23.2 Konkrete Methoden;253
6.2.3;23.3 Mehrfachvererbung;255
6.2.4;23.4 Aufgaben;256
6.3;24 Varianz;258
6.3.1;24.1 Kovarianz von Java-Arrays;258
6.3.2;24.2 Kovarianz von generischen Java-Typen;259
6.3.3;24.3 Mehr Kovarianz in Java;260
6.3.4;24.4 Kontravarianz in Java;261
6.3.5;24.5 Varianz in Scala;261
6.4;25 Pakete und Sichtbarkeit;266
6.4.1;25.1 Pakete in Scala;266
6.4.2;25.2 Sichtbarkeit in Scala;267
6.4.3;25.3 Privater als privat;269
6.5;26 Typumwandlung;272
6.5.1;26.1 Implizite Methoden für implizite Casts;272
6.5.2;26.2 Wozu noch explizite Casts?;274
6.5.3;26.3 Angereicherte Typen;274
6.5.4;26.4 Pimp Your Library!;275
6.5.5;26.5 Sprachfeatures mit impliziten Casts umsetzen;276
6.5.6;26.6 Aufgaben;276
6.6;27 Parallele Programmierung mit Aktoren;278
6.6.1;27.1 Viele Köche verderben den Brei;279
6.6.2;27.2 Parallele Programmierung mal anders;279
6.6.3;27.3 Erste Versuche mit Aktoren;281
6.6.4;27.4 Der Typ Actor;282
6.6.5;27.5 Die Actor-Fabrik;283
6.6.6;27.6 Einfache Standardprobleme und ihre Lösung;284
6.6.7;27.7 Aktoren können antworten;285
6.6.8;27.8 Producer-Consumer-Probleme;286
6.6.9;27.9 Blockierende Stacks;288
6.6.10;27.10 Deadlocks – Nichts geht mehr;289
6.6.11;27.11 Aufgaben;293
7;Literaturverzeichnis;293
8;Stichwortverzeichnis;296
(S. 97-98)
Um mit Scala arbeiten zu können, benötigen wir Werkzeuge wie einen Compiler. Die Website www.scala-lang.org ist das Eingangstor zur Scala-Welt. Hier finden wir Dokumentation, Beispiele, Artikel, Diskussionen und eine kostenlose Entwicklungsumgebung für Scala, die von Entwicklern auf der ganzen Welt gepflegt wird.
8.1 Ohne Java geht nichts
Obwohl die Programmiersprache Scala grundsätzlich an kein spezielles Betriebssystem und keine Laufzeitumgebung gebunden ist, erzeugen die Scala-Compiler seit der Version 2 ausschließlich Java-Bytecode. Zuvor gab es auch Entwicklungsumgebungen für die .Net- Plattform. Mag sein, dass neue Releases künftig wieder .Net unterstützen, zur Zeit ist die Verzahnung mit der Java-Plattform aber sehr eng. Da unsere übersetzten Scala-Programme also in Form von Java-Bytecode vorliegen, benötigen wir zur Ausführung eine Java-Umgebung. Im aktuellen Scala-Release 2.8 liegen auch die beiden Compiler scalac und fsc im Java-Bytecode vor, so dass wir Java benötigen, um überhaupt Scala-Programme übersetzen zu können. Dabei reicht eine Java-Runtime, die komplette Java-Entwicklungsumgebung in Form eines JDK brauchen wir nicht.
Die Scala- Bibliotheken und Werkzeuge setzen die Version 5 von Java voraus, falls auf unserem System nur die Java-Version 1.4 verfügbar ist, muss eine spezielle Scala-Distribution heruntergeladen werden. Auf der Scala Website finden wir nicht nur Entwicklungsumgebungen für Windows und Unix, sondern auch Plugins für Eclipse oder NetBeans. Die zunehmend beliebte Plattform OSGi, die eine komponentenorientierte Softwareentwicklung auf der Java-Plattform ermöglicht, wird ebenfalls unterstützt: Die Scala Bibliotheken sind als OSGi-Bundles verfügbar
8.2 Installation und erste Schritte
Die Entwicklungsumgebung umfasst unter anderem ein Werkzeug zum Ausführen unserer Scala-Programme und zwei Scala-Compiler. Um die Werkzeuge bequem und ohne lange Pfadangaben handhaben zu können, empfiehlt es sich, das bin-Verzeichnis der Scala- Distribution in die Umgebungsvariable PATH des Betriebssystems einzufügen. Nachdem wir die Installation erfolgreich durchgeführt haben, probieren wir die Werkzeuge gleich aus. Im bin-Verzeichnis der Scala-Installation finden wir für jedes Kommando eine Datei mit der Erweiterung bat für Microsoft-Plattformen und eines ohne Erweiterung für Unix-Plattformen.
