Typklassen, Eingabe und Monaden In Haskell

Transkript

1 Typklassen, Eingabe und Monaden In Haskell Felix Rahmati Jonathan Beierle 1 Einleitung In dieser Ausarbeitung befassen wir uns mit den Vorteilen einiger fortgeschrittener Konzepte der funktionalen Programmierung und welche Vorteile diese mit sich bringen. 1.1 Rückblick: Funktionale Programmiersprachen Funktionale Programmiersprachen unterscheiden sich auf den ersten Blick sehr von imperativen und objektorientierten Sprachen wie Java. Unterschiede erkennt man im Aufbau der Programme. Im Gegensatz zu imperativen Programmen findet man in einem funktionalen Programm keine Schleifen. Stattdessen wird ausschließlich mit Rekursion gearbeitet. Außerdem besitzen Klassen und Objekte in der funktionalen Programmierung nicht immer dieselbe Bedeutung, wie in der objektorientierten Programmierung. Des Weiteren gibt man dem Compiler in der imperativen Programmierung einen festen Programmablauf vor, welcher nach und nach abgearbeitet werden muss, während in einem funktionalen Programm lediglich bestimmt wird, was in einem bestimmten Zustand passieren soll und der Compiler, während der Laufzeit, selbst den Programmablauf festlegt. Zudem gibt es in einem rein funktionalen Programm keine veränderbaren Variablen. 1.2 Motivation Aber warum verwendet man funktionale Programmiersprachen eigentlich? Weil diese viele Vorteile bieten, zum einen besitzen funktionale Programme einen sehr einfachen Aufbau, was dazu führt, dass diese Programme sehr schnell zu implementieren sind. Des Weiteren führt der einfache Aufbau, im Vergleich zur imperativen Programmierung, zu einem deutlich kürzeren Quellcode. Außerdem besitzen funktionale Programme den großen Vorteil der Seiteneffektfreiheit, welcher dazu führt, dass diese Programme eine sehr geringe Fehleranfälligkeit besitzen. Das alles führt dazu, dass funktionale Programme zum einen sehr einfach zu warten sind und zum anderen für Außenstehende, im Vergleich, deutlich leichter zu verstehen sind. 1.3 Aufbau Im zweiten Abschnitt befassen wir uns mit dem Konzept der Typklassen, welche ähnlich wie die Interfaces in Java, Typen in einer Klasse zusammenfassen, um das Arbeiten mit diesen Typen zu vereinfachen. Dabei beschäftigen wir uns mit den folgenden Fragen: Was sind Typklassen überhaupt? Welchen Zweck erfüllen sie? Wie genau funktionieren sie? Wie implementiert man sie? 1

2 In dem dritten Abschnitt beschäftigen wir uns mit dem Konzept der Monaden. Wir zeigen, was Monaden überhaupt sind, wie sie funktionieren und damit verbunden, wie sie das Programmieren erleichtern können und Programme so gestalten, dass man sie wieder leichter verändern kann. Am Ende dieses Abschnitts befassen wir uns mit einem Spezialfall der Monaden: Der I/O-Monade. Während dieses Abschnittes behandeln wir ebenfalls die Seiteneffektfreiheit, denn diese bietet, wie oben beschrieben, viele Vorteile. Jedoch ist die Seiteneffektfreiheit in der Praxis kaum umsetzbar, da Eingabe und Ausgabe gewünschte Seiteneffekte sind. Es stellt sich nun die Frage, wie diese Seiteneffektfreiheit in funktionalen Programmen weitgehend erhalten bleibt. 1.4 Haskell Da wir unter anderem einige Beispiele in Form von Quellcode darstellen werden, gehen wir in diesem Teil nochmal wichtige Konzepte der Programmiersprache Haskell durch. Syntax: Eine Typdeklaration wird in Haskell wie folgt dargestellt: Beispiel1.1: name :: type1 -> typeout Beispiel1.2: name :: type1 -> type2 ->... -> typeout In Beispiel1.1 ist name der Name der Funktion, type1 der Typ der Eingabe und typeout der Typ der Ausgabe. Wenn man mehrere Werte eingeben will, kann man das, wie in Beispiel1.2, mittels Currying machen. Dabei wird eine Folge von Argumenten Stück für Stück eingelesen, sodass es den Anschein erweckt, es sei eine Funktion mit mehreren Eingaben. Es gibt in Haskell eine vordefinierte Liste, welche man durch eckige Klammern kennzeichnet, jedoch werden wir im Folgenden eine selbstdefinierte Liste verwenden. Beispiel1.3: data List = LastElement Int RList Int List Der Datentyp List stellt hierbei unsere selbstdefinierte Liste dar. Die Liste soll nie leer sein, weshalb es immer zumindest ein LastElement, vom Typ Integer, gibt. Desweitern gibt es noch die RList, welche ebenfalls einen Integer enthält, jedoch auch eine weitere List. Somit ist dieser Datentyp sehr ähnlich zu einem Stack, in welchem ebenfalls immer das LIFO-Prinzip gültig ist. Mit diesem Wissen können wir nun eine Funktion definieren: Beispiel1.4: (1) restliste :: List -> List (2) restliste RList a b = b (3) restliste LastElement a = LastElement a Hier haben wir eine Funktion restliste, die ein Objekt von Typ List bekommt und ein Objekt vom Typ List ausgibt. Der Funktionskörper beschreibt nun, was die Funktion tun soll. Wie wir sehen, geben wir hier keine genaue Lösung vor, sondern definieren eine 2

3 Fallunterscheidung. Die Liste besteht entweder nur aus einem LastElement (3), oder aus einer RList mit einem Integer a und einer List b (2). Im Fall (2) wird die Liste, ohne ihr erstes Element, also nur b, und im Fall (3) wieder das LastElement a zurückgegeben. Der Compiler wertet dann die Eingabe aus und entscheidet, basierend auf der Eingabe, welcher der beiden Fälle (2) oder (3) ausgeführt wird. Ad-Hoc-Polymorphie: Der Begriff "Überladung" beschreibt die Möglichkeit mehrere Funktionen mit dem gleichen Namen zu benennen. Um nun entscheiden zu können, welche dieser Funktionen ausgeführt wird, wird das Prinzip der Ad-Hoc-Polymorphie verwendet. Um herauszufinden, welche Version der Funktion ausgeführt werden muss, verwendet der Compiler die Information darüber, mit welchem Typ die Funktion aufgerufen wurde. Es wird also "ad-hoc" entschieden, welche Funktion ausgeführt werden soll. Seiteneffektfreiheit: Seiteneffektfreiheit bedeutet unter anderem, dass übergebene Parameter nicht, im Verlauf einer Funktion, verändert werden können. Das führt dazu, dass die Reihenfolge von Funktionsaufrufen keine Rolle spielt, da für gleiche Eingabewerte auch immer die gleichen Ausgabewerte erzeugt werden. Wenn dieser Effekt noch gegeben ist, obwohl die Seiteneffektfreiheit verletzt wurde (zum Beispiel durch eine Eingabe), spricht man von referentieller Transparenz. Dies ist eine der Grundlagen der funktionalen Programmierung. Programme sind dadurch weniger fehleranfällig und weniger komplex. 2 Typklassen In diesem Kapitel befassen wir uns mit den Typklassen, welche ein Konstrukt der funktionalen Programmierung sind. Wir gehen darauf ein was Typklassen eigentlich sind und wir beschäftigen uns mit folgenden Fragen: "Wie funktionieren Typklassen?" und "Wie werden sie implementiert?" 2.1 Konzept Zuerst beschäftigen wir uns damit, was Typklassen sind und erläutern, warum Typklassen so wichtig und weit verbreitet sind. Die Idee hinter Typklassen ist vergleichbar mit der Funktion von Interfaces aus der objektorientierten Programmierung. Dort werden Interfaces dazu verwendet, die Gemeinsamkeiten verschiedener Klassen zusammenzufassen. Ähnlich dazu benutzt man in der funktionalen Programmierung Typklassen um Funktionen, die denselben Zweck erfüllen, für unterschiedliche Typen zusammenzufassen. Dafür wird das Prinzip der Ad-Hoc-Polymorphie verwendet, denn die Funktionen dieser Typklasse tragen für jeden Typen den gleichen Namen (Überladung) und der Compiler muss während der Laufzeit entscheiden, welche Funktion die Richtige ist. Typklassen erleichtern die Programmierarbeit, da der Programmierer sich keine Gedanken darüber machen muss, mit welchen Typen er eine Funktion aufruft. Mittlerweile sind Typklassen eines der wichtigsten Werkzeuge der funktionalen Programmierung. Aufgrund 3

4 dessen werden sie fast überall verwendet, häufig auch für die Definition von Schnittstellen (engl. Interfaces). 2.2 Aufbau Nun schauen wir uns den Aufbau von Typklassen an. Bei der Definition einer Typklasse werden die Namen der Funktionen, welche jeder Typ dieser Typklasse implementieren soll, festgelegt. Genauso wird die Art der Ein- und Ausgabetypen dieser Funktionen bestimmt und mögliche bereits bekannte Typen. Die festgelegten Namen und Typen werden dann für jede Implementierung dieser Funktionen verwendet. Typen dieser Typklasse werden durch einen Platzhalter dargestellt und erst bei der Implementierung durch den eigentlichen Typ ersetzt. Die Elemente einer Typklasse werden Instanzen genannt. Ihre Implementierung verläuft ähnlich zu der einer Unterklasse eines Interfaces, in der objektorientierten Programmierung. In jeder dieser Instanzen werden alle vorgegebenen Funktionen für einen bestimmten Typ (zum Beispiel Bool) implementiert. Ein Typ gehört zu einer Typklasse, falls es eine Instanz in dieser Typklasse gibt, welche alle Funktionen für diesen Typ enthält. 2.3 Implementierung Nachdem wir nun erfahren haben was Typklassen sind und wie sie funktionieren, zeigen wir jetzt anhand eines Beispiels wie man sie implementiert. Dabei werden die Vorteile dieses Konzepts nochmal besonders deutlich. Unser Beispiel ist die Typklasse Eq, welche auf Gleichheit und Ungleichheit prüft. Zu Beginn zeigen wir die Definition der Klasse: Beispiel2.1 (1) class Eq a where (2) (==),(/=) :: a -> a -> Bool Die Zeile (1) signalisiert, dass es sich um eine Klasse handelt und definiert a als Platzhalter für den Typ der Klasse Eq, welcher dann in den Instanzen, durch die Typen der Klasse, ersetzt wird. In Zeile (2) definieren wir nun die beiden Funktionen (==) und (/=) als Funktionen, die zweimal denselben Typen der Typklasse, als Eingabe erhalten und einen Wahrheitswert ausgeben. Als nächstes implementieren wir eine Instanz für die Typklasse Eq: (3) instance Eq Bool where (4) x == y = (x && y) (not x && not y) (5) x /= y = not ((x && y) (not x && not y)) In Zeile (3) wird definiert, dass es sich um die Instanz der Klasse Eq handelt und dass es in dieser Instanz um den Typen Bool geht. In Zeile (4) wird die Funktion (==) definiert, sodass nur True zurückgegeben wird, wenn entweder sowohl x, als auch y True sind, oder beide 4

5 False. In Zeile (5) wird die Funktion (/=), genauso wie die Funktion (==) definiert, nur dass die Ausgabe vorher noch negiert wird. Wie man sieht, kann man also (==) und (/=) als das Gegenteil des anderen definieren. Dafür gibt es für Typklassen eine schöne Lösung, die dem Programmierer Arbeit ersparen kann. Beispiel2.2 (1) class Eq a where (2) (==),(/=) :: a -> a -> Bool (3) x /= y = not (x == y) (4) x == y = not (x /= y) Nun haben wir in den Zeilen (3) und (4) die Abhängigkeit von (==) und (/=) schon in der Typklasse definiert, sodass wir in den Instanzen jeweils nur eins der beiden implementieren müssen. (5) instance Eq Bool where (6) x == y = (x && y) (not x && not y) (7) instance Eq Int where (8) x /= y = (x - y) < 0 (x - y) > 0 Durch die Kombination der Zeilen (6) und (3) ist nun sowohl (==) als auch (/=) für die Instanz definiert. Dasselbe gilt für die Instanz von Int und die Zeilen (8) und (4). Wie man sehen kann, erspart diese Technik dem Programmierer bei jeder neuen Instanz etwas Arbeit. Da wir nun dargestellt haben, wie man Typklassen implementiert, zeigen wir jetzt, wie man sie verwendet und einzelne Funktionen aufruft. So wird, zum Beispiel wenn man 3 == 4 aufruft, die Typklasse nach der Instanz von Int abgesucht. In dieser Instanz wird die Funktion (==) gesucht, welche in dieser Instanz als nicht (/=) definiert ist, sodass letzten Endes aus 3 == 4 die Abfrage not (3 /= 4) wird. Genauso könnten wir True == True aufrufen und der Compiler würde auch hierfür die passende Interpretation finden. Er würde nach der Instanz für Bool von Eq suchen und dort die definierte Funktion (==) verwenden. Wir sehen also, dass Typklassen ein starkes Werkzeug der funktionalen Programmierung sind, mit denen das Programmieren und verstehen des Codes vereinfacht wird. 5

6 3 Monaden Monaden sind ein sehr wichtiges Konzept der funktionalen Programmierung. Durch dieses Konzept können Programmteile gekapselt werden, sodass man Berechnungen getrennt voneinander ausführen kann, was auch dazu genutzt wird, um die Seiteneffekte zu kapseln. Desweitern lassen Programmeteile, sich durch Monaden, leichter abändern und wiederverwenden. Um dieses Thema zu erklären werden wir zuerst den Aufbau und Zweck von Monaden erläutern, dann, anhand von Beispielen, darstellen wie man mit ihnen programmiert und zuletzt den Spezialfall der I/O-Monade betrachten. 3.1 Einführung Im Verlauf dieses Abschnitts werden wir auf das Konzept, den Aufbau und die Gesetze von Monaden eingehen. Konzept: Monaden sind ein bedeutendes Werkzeug der funktionalen Programmierung und werden zur Behandlung von Fehlern und Ausnahmen und zur Ein- und Ausgabe verwendet. Außerdem helfen sie dabei, dass Programme in Module unterteilt werden und dadurch wesentlich einfacher wiederzuverwerten und zu verändern sind. Diese Vorteile werden durch das Prinzip der Kapselung erreicht. Eine Monade kapselt Aufgaben eines Programms und führt diese unabhängig von der Umgebung aus. So werden zum Beispiel Berechnungen in einer Funktion voneinander getrennt, sodass man bei Änderungswunsch nur die Monadendefinition, aber nicht das komplette Programm, umschreiben muss. Dadurch wird das Programm deutlich lesbarer und ist einfacher zu warten. Denn das Programm wird, durch die Kapselung, in Module unterteilt. Dies kann auch dazu benutzt werden, um Seiteneffekte in Monaden zu kapseln und so die referentielle Transparenz im Rest des Programms zu gewährleisten. Monaden gehören zu den Konstruktorklassen, um also verstehen zu können was genau eine Monade ist, muss man zuerst verstanden haben was Konstruktorklassen sind. Konstruktorklassen: Konstruktorklassen sehen den Typklassen sehr ähnlich. Der wichtige Unterschied hierbei ist, dass Typklassen dazu verwendet werden, Funktionen für unterschiedliche Typen zusammenzufassen. Konstruktorklassen hingegen werden dazu verwendet, Funktionen für unterschiedliche Konstruktoren zu sammeln. Konstruktoren können zum Beispiel Funktionen der Form * -> * sein, wobei * entweder ein Typ oder ein weiterer Konstruktor ist. Sie können auch als erweiterte Typklassen bezeichnet werden, da sie die Aufgabe der Typklassen auch auf Konstruktoren ausweiten. Aufbau und Implementierung: Nun befassen wir uns mit dem Aufbau einer Monade, dazu schauen wir uns einen Auszug der Definition der Konstruktorklasse Monad an. 6

7 Beispiel3.1 (1) class Monad m where (2) return :: a -> m a (3) (>>=) :: m a -> (a -> m b) -> m b Der Aufbau ist prinzipiell sehr ähnlich zu dem Aufbau einer Typklasse. Der Unterschied hierbei ist, dass m hier kein Platzhalter für einen Typ, sondern für einen Konstruktor ist. a und b sind gewöhnliche Typen. Der Rest ist identisch zu den Typklassen, also Zeile (1) ist die Kopfzeile und in den Zeilen (2) und (3) werden die Funktionen, welche in jeder Monade enthalten seien müssen, definiert. Die Funktion in Zeile (2) ist die return"-funktion. Diese dient dazu, Werte oder Aktionen in der Monade zu kapseln. Das wird dadurch deutlich, dass in dem Code aus dem a ein m a gemacht wird. Mit anderen Worten: Der Aufruf return a kapselt a in eine Monade m. Einen solchen gekapselten Wert werden wir im Folgenden so darstellen: Es gibt noch weitere Funktion, welche oben nicht definiert sind, eine davon ist der then- Operator, welcher wie folgt definiert ist: (>>) :: m a -> m b -> m b Dieser wird dazu verwendet, um mehrere Aufrufe hintereinander auszuführen. Das Problem beim then-operator ist, dass wir das Ergebnis von m a verlieren, sobald wir m b ausführen, da das Ergebnis nicht weitergegeben wird. Dadurch ist der then-operator nur nützlich, wenn uns das Ergebnis egal ist und sieht wie folgt aus: Also benutzen wir den bind"-operator, mit dem man sozusagen einen Wert übergeben kann und welcher in Zeile 3 definiert ist. Das funktioniert so, indem m a ausgeführt und das Ergebnis genommen wird. Darauf wird dann "m b" ausgeführt und als Ergebnis erhält man dann einen Wert vom Typ m b. Das sieht dann so aus: Das Schema, der Erzeugung von neuen Instanzen, ist dasselbe wie bei den Typklassen. Die Monaden sind die Elemente, also die Instanzen, der Konstruktorklasse Monad. Die Instanzendeklaration ist genau gleich, wie bei den Typklassen. Man startet also mit der Zeile: instance Monad name where Anschließend müssen die Funktionen "return" und "bind" für die Monade individuell implementiert werden. Monadengesetze: Für die Definition der Funktionen einer Monade gibt es drei Gesetze. Diese beschreiben einige Regeln, wie sich die Funktionen verhalten sollen. Der Compiler kann nicht 7

8 überprüfen, ob die Gesetze erfüllt sind oder nicht, jedoch spricht man erst von einer Monade, wenn alle drei Gesetze gelten. Daher sollte jeder gute Code diesen Gesetzen entsprechen. 1. p >>= return = p Wenn man zuerst eine Aktion p ausführt und daraufhin die Aktion return verwendet, erhält man dasselbe Ergebnis, wie wenn man nur die Aktion p aufruft. Die erste Regel besagt also, dass return das rechtsneutrale Element zu >>= ist. 2. return x >>= f = f x Es wird zuerst die Aktion return, mit einer beliebigen Eingabe x, aufgerufen und auf das Ergebnis eine Aktion f verwendet, welche das gekapselte Element x benutzt, sodass das gleiche heraus kommt, als würde man einfach nur f x ausführen. Also sagt die zweite Regel aus, dass return ebenfalls das linksneutrale Element zu >>= ist. Regel 1 und 2 stellen in Kombination sicher, dass return sowohl linksneutral als auch rechtsneutral, zu der bind-funktion, ist und somit die "leere Aktion" implementiert. 3. (p >>= \x -> q) >>= r = p >>= \x -> (q >>= r) falls x nicht in r auftritt. Auf der linken Seite führen wir zuerst die Aktion p und daraufhin die Aktion q, mit dem Ergebnis von p, aus. Zuletzt wird die Aktion r, mit dem Ergebnis von q, durchgeführt. Auf der rechten Seite werden stattdessen die Aktionen q und r gebündelt und darauf dann das Ergebnis von p aufgerufen. Da laut Gesetz beide Seiten das Identische bewirken, kann man schlussfolgern, dass das dritte Gesetz die Asoziativität von >>= beschreibt. Mit anderen Worten, wir können Klammern setzen, ohne damit eine Veränderung des Ergebnisses zu bewirken. 3.2 Implementierung (Beispiel) In diesem Kapitel werden wir uns damit beschäftigen, wie man mit Monaden programmiert und welche Vorteile das hat. Dies werden wir anhand eines Beispiels, in welchem wir einmal keine Monade verwenden und dann zum Vergleich die Maybe Monade benutzen, erläutern. Wir wollen nun eine Funktion f implementieren, die eine selbstdefinierte Liste von Integern erhält und die Summe ihrer Elemente bestimmt. Allerdings soll die Einschränkung gelten, dass die Liste keine ungeraden Zahlen enthält. Sollte die Liste dennoch welche enthalten, so soll Nothing zurückgegeben werden. Dafür erstellen wir zunächst zwei eigene Datentypen: data Maybe a = Just a Nothing data List = LastElement Int RList Int List Hierbei beschreibt Maybe die Art unserer Ausgabe. Erlaubte Werte, als gerade Integer Zahlen, sollen als Just x bezeichnet werden, wobei x genau dieser Wert ist. Nothing wird verwendet, wenn ein ungerader Integer, in der Liste, enthalten ist und stellt somit eine Art 8

9 Fehlerausgabe dar. Der Datentyp List ist hierbei derselbe wie der, den wir in Kapitel 1 eingeführt haben. Nun definieren wir unsere Funktion f: f :: List -> Maybe Int f (LastElement x) (mod x 2) == 0 = Just x otherwise = Nothing f (RList x y) = case f y of Nothing -> Nothing Just y -> case (mod x 2) of 0 -> Just (x + y) 1 -> Nothing Die Funktion f bekommt als Eingabe ein Objekt List und gibt einen Maybe Int Wert zurück. Bei der Eingabe müssen wir nun in zwei Fälle unterscheiden: Im ersten Fall ist die Eingabe ein LastElement x. Es muss hierbei vorerst überprüft werden, ob x ein gerader oder ungerader Integer Wert ist. Dies wird mittels einer Fallunterscheidung umgesetzt. Sollte (mod x 2) gleich 0 sein, also x ist ein gerader Integer und somit ein gültiger Wert, wird Just x zurückgegeben. Sollte das nicht zutreffen, also x ist ungerade und somit ein ungültiger Wert, wird Nothing zurückgegeben. Im zweiten Fall erhält die Funktion f eine RList. Zuerst wird die Funktion f rekursiv auf die restliche Liste y (vom Typ List) angewendet. Sollte Nothing zurückgegeben werden, was bedeutet, dass die Liste y einen ungültigen Wert enthält, so gibt auch die Funktion f wieder Nothing zurück. Wenn jedoch Just a zurückgegeben wird, wobei a ein Integer ist, welcher die Summe aller Elemente von y darstellt, so wird nun mit der Modulo Funktion überprüft, ob der Wert von x gerade ist. Sollte dies so sein, bedeutet das, dass weder x ungültig ist, noch dass y einen ungültigen Wert enthält. Dann wird als Ergebnis Just mit der Summe von x und a zurückgegeben. Sollte x jedoch ungerade und somit ungültig sein, wird einfach Nothing zurückgegeben. Nun zeigen wir, wie das Ganze mit einer Monade implementiert wird und werden hierbei die Vorteile einer Monade nochmals erläutern. Dazu erklären wir zuerst die Definition der Maybe Monade: instance Monad Maybe where return x = Just x Nothing >>= q = Nothing Just x >>= q = q x Diese Monade ist eine Instanz der Konstruktorklasse Monad und trägt den Namen Maybe. Es ist eine der am häufigsten verwendeten Monaden die es gibt, da sie dem Programmierer erlaubt, etwas auszudrücken, was vielleicht gar nicht vorhanden ist. Die return Funktion, gibt auf jede Eingabe x, Just x zurück. Für die bind Funktion muss man zwischen zwei Fällen unterscheiden: Der erste Fall besagt, dass wenn man Nothing, mit einer anderen Funktion, verknüpfen will, kommt wieder Nothing heraus. Im zweiten Fall 9

10 wird Just x mit einer beliebigen Funktion q verknüpft und die Ausgabe ist das Ergebnis, der Funktion q, wenn man sie auf x anwendet. Jetzt schreiben wir unsere Funktion f mit der Hilfe der Monade um. Diese neue Funktion nennen wir fm und sieht wie folgt aus: fm :: List -> Maybe Int fm (LastElement x) (mod x 2) == 0 = return x otherwise = Nothing fm (RList x y) = do a <- fm y if (mod x 2) == 0 then return (a + x) else Nothing Der Grundaufbau der Funktion fm ist derselbe, wie der unserer Funktion f. Wir bekommen hier auch ein Objekt List, als Eingabe der Funktion, und geben ebenfalls einen Maybe Int Wert zurück. Wir haben auch, in der Funktion fm, wieder die Fallunterscheidung für die Eingaben LastElement x und RList x y. Der erste Fall wird fast gleich implementiert, wie in der Funktion f. Der einzige Unterschied besteht darin, dass wir die Monade, bei der Ausgabe, verwenden, also statt Just x geben wir return x aus. Im zweiten Teil, der Funktion, wird deutlich mehr verändert. Hierbei verwenden wir die do-notation, welche eine spezielle Notation für Verknüpfungen von "bind"-operatoren ist. Dies ist also keine neue Funktion, sondern vereinfacht nur die Schreibweise und macht den Code verständlicher. Die alternative Form, für die do-notation unseres Beispiels, sähe so aus: fm (RList x y) = fm y >>= \a -> if ((mod x 2) == 0) then return (a + x) else Nothing Wir führen also zuerst die Funktion fm auf y aus und setzen a auf den darin gekapselten Wert. Dann wird mittels einer if-abfrage überprüft, ob x ein gültiger Werte ist, also ob x ein gerader Integer Wert ist. Wenn dies der Fall ist wird das Ergebnis, also die Summe von a und x, mittels der return-funktion in der Monade gekapselt, zurückgegeben. Ansonsten wird Nothing als Monaden-Objekt ausgegeben. Wir haben nun eine Funktion auf zwei verschiedene Arten definiert. Einmal komplett ohne den Einsatz von Monaden und einmal mit Benutzung der Maybe Monade. Im Vergleich stellt sich nun die Frage, wieso man überhaupt Monaden verwendet, da das Beispiel mit Monade nicht wesentlich kürzer erscheint und mit der Definition der Monade sogar noch länger ist. Jedoch muss man beachten, dass wir hier lediglich eine Funktion implementiert haben und man auf diese Art und Weise natürlich viele Funktion implementieren kann, ohne dafür eine neue Monade definieren zu müssen. Außerdem wird der Code dadurch deutlich verständlicher, da man die case-verschachtelung umgeht. Des Weiteren können wir nun, durch die Modularität, welche durch die Monade zustande kommt, die Programme sehr viel einfacher anpassen, da man nur noch die einzelnen Module, also die Monaden, verändern muss und nicht jede einzelne Funktion. Wenn man all diese Aspekte betrachtet, kann man nun feststellen, dass es doch sehr sinnvoll ist, mit Monaden zu arbeiten und dass sich das in der Praxis sehr lohnen kann. 10

11 3.3 I/O-Monade Zu Beginn haben wir uns die Frage gestellt, wie man mit Seiteneffekten, in der funktionalen Programmierung umgeht. Auch hier kommt uns das Konzept der Monade zu Hilfe und zwar in Form der I/O-Monade, welche ein Spezialfall der Konstruktorklasse Monad ist. Die I/O-Monade ist eine der wichtigsten und meist verwendeten Monaden, da sie für die Eingabe und Ausgabe zuständig ist. Das Besondere bei der I/O-Monade ist, dass sie keine Werte speichert, sondern Aktionen. Das heißt, Werte werden in diesen Aktionen gekapselt. Genauer erkennt man das an folgendem Beispiel: getchar :: IO Char Die Funktion getchar wird dazu benutzt, um Tastatureingaben einzulesen. Allerdings speichert IO keine Werte, also auch keine Tastatureingaben. In diesem Fall wird sozusagen die Aktion "lese ein" gespeichert. Das führt dazu, dass man keine Werte aus einer I/O- Monade extrahieren kann. Dies ist sehr wichtig, da die Werte, mit denen IO arbeitet, Seiteneffekt behaftet sind. Würde man diese Werte extrahieren können, hätte man die Seiteneffekte in seinem Programm und die referentielle Transparenz wäre verletzt. Eine weitere Funktion, die auf der I/O-Monade beruht ist putchar: putchar:: Char -> IO () Die Funktion putchar dient zur Ausgabe und gibt ein Zeichen aus. Auch hier ist zu erkennen, dass lediglich eine IO Aktion und kein fester Wert gespeichert wird. Um nochmal zu verdeutlichen, wie wichtig dies ist, nehmen wir folgendes Beispiel: getchar >>= putchar Hier lesen wir zuerst eine Tastatureingabe ein und geben diese anschließend aus. Durch die Eingabe bekommen wir Seiteneffekte. Unsere, durch "bind" verknüpfte, Funktionen beschreiben nun die Aktionen "lese Wert ein und gebe ihn aus". Der Wert bleibt dabei dauerhaft gekapselt und hat keinen Einfluss auf unser übriges Programm. Die referentielle Transparenz unseres Programms ist also weiterhin gegeben. Würden wir diese Seiteneffekte in unser Programm lassen, müssten wir unter anderem darauf achten, in welcher Reihenfolge wir Funktionen aufrufen, da wir nicht immer das gleiche Ergebnis erwarten können. Dies würde auch das Programmieren erschweren und die in der Einleitung genannten Vorteile zunichtemachen. Wie wir sehen können, hilft uns die I/O- Monade dabei unsere Programme, auch bei Ein- und Ausgabe, weitgehend Seiteneffektfrei zu halten. 11

12 4 Zusammenfassung Wir haben jetzt einige der wichtigsten Konzepte der funktionalen Programmierung kennen gelernt. Nachdem wir uns mit den Vorteilen und Besonderheiten der funktionalen Programmierung beschäftigten, haben wir uns mit dem Konzept der Typklassen befasst. Dies ist ein sehr wichtiges Konzept, da es ermöglicht Funktionen für viele verschiedene Typen unter demselben Namen zu implementieren und zusammenzufassen. Dieses Konzept trägt dadurch nicht nur zur Lesbarkeit bei, sondern verringert auch die Fehleranfälligkeit und sorgt dafür, dass Funktionen wesentlich einfacher und schneller zu implementieren sind. Anschließend haben wir uns dem großen Thema Monaden gewidmet. Wir haben gezeigt, dass sie das Programmieren auf unterschiedlichen Ebenen erleichtern. Zum einen sorgen sie dafür, dass die Modularität des Programms gesteigert wird, was dazu führt, dass man einzelne Teile des Programms leichter verändern kann. Zum anderen wird der Code dadurch deutlich lesbarer und ist für Außenstehende einfacher zu verstehen. Außerdem wird mithilfe der I/O-Monade die referentielle Transparenz, durch die Kapselung von Werten in Aktionen, bewahrt und stellt damit einen wichtigen Aspekt der funktionalen Programmierung sicher. Abschließend bleibt zu sagen, dass funktionale Programmiersprachen sich zwar deutlich von imperativen Sprachen unterscheiden und man sich erstmal an diese Sprachen gewöhnen muss, bevor man effizient mit ihnen arbeiten kann. Jedoch bringen sie viele Vorteile mit sich, durch die das Programmieren vereinfacht wird. Man kann also sagen, dass es sich oft durchaus lohnt auf funktionale Programmiersprachen zurückzugreifen. Quellen - Skript zur Vorlesung: Funktionale Programmierung, SS 2016, Jürgen Giesl, - Tackling the Awkward Squad: monadic input/output, concurrency, exceptions, and foreign-language calls in Haskell, Simon Peyton Jones, - Real World Haskell by Bryan O'Sullivan, Don Stewart, and John Goerzen, 2010, O'Reilly 12