Einführung in die funktionale Programmierung

Funktioniert’s?
Funktionale Programmierung für Anfänger

Funktional, das ist doch nur für Esoteriker?!

ABN AMRO Amsterdam Risikoanalysen Investmentbanking
AT&T Netzwerksicherheit: Verarbeitung von
Internet-Missbrauchsmeldungen
Bank of America Merril Lynch
Backend: Laden & Transformieren von Daten
Barclays Capital Quantitative Analytics Group
Mathematische Modellierung von Derivaten
Bluespec, Inc. Modellierung & Veriﬁkation integrierter Schaltkreise
Credit Suisse Prüfen und Bearbeiten von Spreadsheets
Deutsche Bank Equity Proprietary Trading, Directional Credit
Trading Gesamte Software-Infrastruktur
Facebook Interne Tools
Factis Research, Freiburg Mobil-Lösungen (Backend)
fortytools gmbh Webbasierte Produktivitätstools - REST-Backend
Functor AB, Stockholm Statische Codeanalyse

Galois, Inc Security, Informationssicherheit, Kryptographie
Google Interne Projekte
IMVU, Inc. Social entertainment
JanRain Netzwerk- und Web-Software
MITRE Analyse kryptographischer Protokolle
New York Times Bildverarbeitung für die New York Fashion Week
NVIDIA In-House Tools
Parallel Scientiﬁc Hochskalierbares Cluster-Verwaltungssystem
Sankel Software CAD/CAM, Spiele, Computeranimation
Silk, Amsterdam Filtern und Visualisieren großer Datenmengen
Skedge Me Online-Terminvereinbarungen
Standard Chartered Bankensoftware
Starling Software, Tokio Automatisiertes Optionshandelssystem
Suite Solutions Verwaltung technischer Dokumentationen
(Quelle: http://www.haskell.org/haskellwiki/Haskell_in_industry)

Bekannte funktionale Sprachen
Lisp
Scheme
ML
OCamlMiranda
F#
Erlang
Clojure
Scala
Haskell

Bekannte funktionale Sprachen
Lisp
Scheme
ML
OCamlMiranda
F#
Erlang
Clojure
Scala
Haskell
(JavaScript)
(Java 8)

Was ist denn an funktionaler Programmierung so besonders?

Immutability

Immutability
Jeder Variablen darf nur einmal ein Wert zugewiesen werden

Immutability
In Java nicht direkt unterstützt

Immutability
In Java nicht direkt unterstützt
Kann trotzdem leicht verwirklicht werden:
class Point {
private final int x, y;
public Point (int x, int y) {
this.x = x;
this.y = y;
}
// only read x and y in the remaining code
}

Seiteneﬀektfreiheit

„alles, was den Ablauf eines Computerprogramms oder die Außenwelt
verändert, ohne von einer Funktion berechnet worden zu sein“

Ein-/Ausgabe
Exceptions
Logging
Abhängigkeit von (externen) Konﬁgurationen
Veränderungen des Zustands
Nichtdeterminismus (z. B. Zufallszahlengenerator)

Ein-/Ausgabe
Exceptions
Logging
Abhängigkeit von (externen) Konﬁgurationen
Veränderungen des Zustands
Nichtdeterminismus (z. B. Zufallszahlengenerator)
Manche Sprachen zeigen das Vorhandensein von Seiteneﬀekten sogar
in der Typsignatur an

auch nicht direkt durch Java 8 unterstützt - Codierungsregeln helfen

auch nicht direkt durch Java 8 unterstützt - Codierungsregeln helfen
class SeparationOfSideEffects {
public void withSideEffect(){
String initialValue = System.console().readLine();
String result = withoutSideEffect(initialValue);
System.out.println("The Result: " + result);
}
public static String withoutSideEffect(String initialValue){
return /* function result */ ;
}
}

Funktionen sind „ﬁrst order citizens“

Funktionen sind „ﬁrst order citizens“
Mit Funktionen kann man dasselbe machen wie mit Strings oder Zahlen

Funktionen sind Werte
Java 8: Statische Methoden
class Examples { static int staticTimes (int x, int y) { return x * y; } }
IntBinaryOperator timesVar = Examples::staticTimes;
timesVar.applyAsInt(3, 5); // 15

Java 8: Objektmethoden
class Examples { int times (int x, int y) { return x * y; } }
Examples examples = new Examples();
IntBinaryOperator timesVar = examples::times;
timesVar.applyAsInt(3, 5); // 15

Java 8: Lambdas
IntBinaryOperator times = (x, y) -> x * y;
times.applyAsInt(3, 5); // 15

Java 8: Lambdas (mit eigenem Funktionsinterface)
interface TimesFunction { int eval(int x, int y); }
TimesFunction times = (x, y) -> x * y;
times.eval(3, 5); // 15

Java 8: Lambdas (mit eigenem Funktionsinterface)
interface TimesFunction { int eval(int x, int y); }
TimesFunction times = (x, y) -> x * y;
times.eval(3, 5); // 15
Haskell:
times x y = x * y
timesVar = times
timesVar 3 5 -- 15

Funktionen sind Funktionsparameter

Java 8:
class Examples {
static int apply(IntUnaryOperator func, int arg) {
return func.applyAsInt(arg);
}
}
Examples.apply(x -> 3 * x, 5); // 15

Java 8:
class Examples {
static int apply(IntUnaryOperator func, int arg) {
return func.applyAsInt(arg);
}
}
Examples.apply(x -> 3 * x, 5); // 15
Haskell:
apply func arg = func arg
apply ( x -> 3 * x) 5 -- 15

Funktionen sind Rückgabewerte

Java 8:
interface FunctionFunction { IntUnaryOperator eval(int x); }
FunctionFunction times = x -> { return y -> x * y; };
times.eval(3).applyAsInt(5); // 15

Java 8:
interface FunctionFunction { IntUnaryOperator eval(int x); }
Haskell:
times x = (y -> x * y)
times 3 5 -- 15

Komisch, oder?
Java 8: Zwei verschiedene Aufrufe
IntBinaryOperator times = (x, y) -> x * y;
times.applyAsInt(3, 5); // 15
Haskell: Zweimal derselbe Aufruf
times x y = x * y
times 3 5 -- 15
times 3 5 -- 15

Currying! (oder auch Schönﬁnkeln)

In manchen funktionalen Sprachen schreiben wir:
times x y = x * y
und eigentlich passiert Folgendes:

times x y = x * y
Denn: Funktionen haben immer genau ein Argument

times x y = x * y
Denn: Funktionen haben immer genau ein Argument
Nutzen: Partielle Evaluierung:
times x y = x * y
times3 = times 3
times3 5 -- 15

Wichtige Bibliotheksfunktionen: ﬁlter
ﬁlter oder auch select

Nimmt eine Collection und eine Funktion
Liefert diejenigen Elemente der Collection, für die die Funktion true
ergibt

ergibt
Java 8:
Stream<Integer> filteredStream =
asList(1, 2, 3, 4).stream().filter(x -> x % 2 == 0);
filteredStream.toArray(); // new Integer[]{2, 4}
filteredStream.collect(Collectors.toList()); // Liste mit 2 und 4

ergibt
Java 8:
Stream<Integer> filteredStream =
asList(1, 2, 3, 4).stream().filter(x -> x % 2 == 0);
filteredStream.toArray(); // new Integer[]{2, 4}
filteredStream.collect(Collectors.toList()); // Liste mit 2 und 4
Haskell:
filter (x -> x `mod` 2 == 0) [1,2,3,4] -- [2,4]

Wichtige Bibliotheksfunktionen: map
map oder auch collect

Liefert eine Collection, in der die Funktion auf jedes Element der
ursprünglichen Collection angewandt wurde

Java 8:
Arrays.asList(1, 2, 3, 4).stream().map(x -> x + 5).toArray();
// new Integer[]{6, 7, 8, 9}

Java 8:
Arrays.asList(1, 2, 3, 4).stream().map(x -> x + 5).toArray();
// new Integer[]{6, 7, 8, 9}
Haskell:
map (x -> x + 5) [1,2,3,4] -- [6,7,8,9]

Wichtige Bibliotheksfunktionen: reduce
reduce oder auch foldl / foldr oder inject

Nimmt eine Collection, eine Funktion und einen Startwert
Verbindet Startwert und erstes Element der Collection mit Hilfe der
Funktion
Verbindet das Ergebnis mit dem nächsten Element der Collection
Setzt dies für alle Elemente der Collection fort, bis nur noch ein
Element übrigbleibt

Java 8:
Arrays.asList(2, 3, 4, 5).stream().reduce(1, (x, y) -> x*y); // 120

Java 8:
Arrays.asList(2, 3, 4, 5).stream().reduce(1, (x, y) -> x*y); // 120
Haskell:
foldl (*) 1 [2,3,4,5] -- 120

Typinferenz
Haskell: starkes statisches Typsystem
Leichtgewichtige Verwendung dank Typinferenz
Herleitung des allgemeinst möglichen Typs

Typinferenz
Beispiel:
f x = x

Typinferenz
Beispiel:
f x = x
Typ:
f :: a -> a
a : Typvariable (vergleichbar mit Generics in Java o. ä.)
-> Funktionstyp (Argumenttyp steht links, Ergebnistyp steht rechts)

Typinferenz (2)
f x = x + 1
Typ:
f :: Num a => a -> a
Num a : Typklasse. Einschränkung der Typvariablen a auf numerische
Typen

Typinferenz (2)
f x = x + 1
Typ:
f :: Num a => a -> a
Num a : Typklasse. Einschränkung der Typvariablen a auf numerische
Typen
Empfehlung: Typsignatur stets annotieren! Zur Überprüfung der eigenen
Annahmen.

Eine einfache Berechnung
sum =
10
i=1
i2

Eine einfache Berechnung
sum =
10
i=1
i2
int sum = 0;
for(int i = 1; i <= 10; i++) {
sum = sum + i * i;
}

Exkurs: Clean Code
Single Responsibility Principle

Exkurs: Clean Code
Wie viele Verantwortlichkeiten hat dieser Code?
int sum = 0;
for(int i = 1; i <= 10; i++) {
sum = sum + i * i;
}

Exkurs: Clean Code
int sum = 0;
for(int i = 1; i <= 10; i++) {
sum = sum + i * i;
}
Erzeugen der Zahlenfolge von 1 bis 10

Exkurs: Clean Code
int sum = 0;
for(int i = 1; i <= 10; i++) {
sum = sum + i * i;
}
Quadrieren einer Zahl

Exkurs: Clean Code
int sum = 0;
for(int i = 1; i <= 10; i++) {
sum = sum + i * i;
}
Berechnen der Quadratzahl jeder Zahl in der Folge

Exkurs: Clean Code
int sum = 0;
for(int i = 1; i <= 10; i++) {
sum = sum + i * i;
}
Addieren zweier Zahlen

Exkurs: Clean Code
int sum = 0;
for(int i = 1; i <= 10; i++) {
sum = sum + i * i;
}
Aufsummieren der Quadratzahlen

Trennen der Verantwortlichkeiten

IntStream sequence = IntStream.rangeClosed(1, 10);

IntUnaryOperator square = x -> x*x;

IntStream squaredSequence = sequence.map(square);

IntBinaryOperator add = (x,y) -> x+y;

IntBinaryOperator add = (x,y) -> x+y;
Integer sum = squaredSequence.reduce(0, add);

Zusammensetzen der Komponenten
Java 8:
IntStream.rangeClosed(1, 10).map(x -> x*x).reduce(0, (x,y) -> x+y); // 385

Java 8:
Haskell:
foldl (+) 0 (map (x -> x*x) [1..10]) -- 385

Java 8:
Haskell:
foldl (+) 0 (map (x -> x*x) [1..10]) -- 385
oder
(>.>) x f = f x
[1..10] >.> map (x -> x*x) >.> foldl (+) 0 -- 385

Uﬀ!
OK, alle einmal tief durchatmen :-)

Pattern Matching
Fibonacci-Funktion „naiv“:
fib x = if x < 2 then x else fib (x-1) + fib (x-2)

Pattern Matching
Fibonacci-Funktion „naiv“:
fib x = if x < 2 then x else fib (x-1) + fib (x-2)
Fibonacci-Funktion mit Pattern Matching:
fib 0 = 0
fib 1 = 1
fib x = fib (x-1) + fib (x-2)

Algebraische Datentypen
Binärbaum:
data Tree =
Node Tree Tree
| Leaf Int

Binärbaum:
data Tree =
Node Tree Tree
| Leaf Int
myTree = Node (Node (Leaf 4) (Node (Leaf 7) (Leaf 1))) (Leaf 3)

Binärbaum:
data Tree =
Node Tree Tree
| Leaf Int
Summenfunktion:

Binärbaum:
data Tree =
Node Tree Tree
| Leaf Int
Summenfunktion:
treeSum (Leaf x) = x

Binärbaum:
data Tree =
Node Tree Tree
| Leaf Int
Summenfunktion:
treeSum (Node m n) = treeSum m + treeSum n

Binärbaum:
data Tree =
Node Tree Tree
| Leaf Int
Summenfunktion:
treeSum (Node m n) = treeSum m + treeSum n
treeSum myTree -- 15

Fazit
Funktionale Programmierung ist verbreiteter als man denkt
Manches lässt sich in den nicht-funktionalen Alltag integrieren
Viele Sprachen bringen funktionale Aspekte oder Zusatzmodule mit

Fazit
Funktionale Programmierung ist verbreiteter als man denkt
Manches lässt sich in den nicht-funktionalen Alltag integrieren
Viele Sprachen bringen funktionale Aspekte oder Zusatzmodule mit
Referenz:
Haskell: http://www.haskell.org

Vielen Dank!
Code & Folien auf GitHub:
https://github.com
/NicoleRauch/FunctionalProgrammingForBeginners
Nicole Rauch
E-Mail info@nicole-rauch.de
Twitter @NicoleRauch
Web http://www.nicole-rauch.de
Artikel in der nächsten (?) Java Aktuell
Ganztägiger Workshop

Einführung in die funktionale Programmierung

Weitere ähnliche Inhalte

Was ist angesagt? (16)

Ähnlich wie Einführung in die funktionale Programmierung (20)

Mehr von Digicomp Academy AG (20)

Einführung in die funktionale Programmierung