Monaden Motivation Definition der Typklasse Monad Definition der ...

Motivation
Monaden
Horst Hansen
Hochschule für Technik und Wirtschaft Berlin
Studiengang Angewandte Informatik
Sommersemester 2012
Monaden sind Konstruktionen, die auf polymorphen (generischen)
Typen aufbauen.
Monaden selbst werden definiert als instance-Deklarationen der
monadischen Klassen Functor, Monad oder MonadPlus. Von
monadischen Klassen kann nicht abgeleitet werden.
Neben dem polymorphen Typ IO sind auch die polymorphen
Typen Maybe und Listen ([]) monadische Klassen.
c○ Horst Hansen Monaden 1
c○ Horst Hansen Monaden 2
Definition der Typklasse Monad
In der Klasse Monad werden die Basisfunktionen einer Monade
definiert.
1 class Monad m where
2 (>>=) :: m a -> (a -> m b) -> m b
3 (>>) :: m a -> m b -> m b
4 return :: a -> m a
5 m >> k = m >>= \_ -> k
Alle instance-Deklarationen von Monad müssen die folgenden
Gesetze erfüllen:
1 return a >>= k = k a
2 m >>= return = m
3 m >>= (\x -> k x >>= h) = (m >>= k) >>= h
Instanzen von Monad und Functor müssen zusätzlich dieses
Gesetz erfüllen:
1 fmap f xs = xs >>= return . f
Definition der Typklasse Functor
Bevor wir uns daran machen, die Funktionen der Typklasse Monad
zu verstehen, schauen wir uns erst einmal die einfachere Typklasse
Functor an, die wir anschließend benötigen werden.
1 class Functor f where
2 fmap :: (a -> b) -> f a -> f b
Die hier deklarierte Funktion fmap ist eine Verallgemeinerung der
schon bekannten Funktion map:
1 map :: (a -> b) -> [a] -> [b]
Man beachte, daß f eine freie Typvariable ist, die auf zwei weitere
freie Typvariablen a und b angewendet wird!
c○ Horst Hansen Monaden 3
c○ Horst Hansen Monaden 4

Gesetze in der Typklasse Functor
Instanz-Deklaration zu der Typklasse Functor
In allen Instanzen der Typklasse Functor müssen für die Funktion
fmap die folgenden Gleichungen erfüllt sein:
1 fmap id = id
2 fmap (f . g) = fmap f . fmap g
Diese Gesetze dücken aus, daß die Funktion fmap weder den
vorliegenden Behältertyp verändert noch die Inhaltselemente
anders anordnet.
Somit sollte das Folgende funktionieren: Wenn wir einen
polymorphen (generischen) Typ Tree a definiert haben durch
1 data Tree a = Leaf a | Branch (Tree a) (Tree a)
sollte es möglich sein, zu definieren:
1 instance Functor Tree where
2 fmap f (Leaf x) =Leaf (f x)
3 fmap f (Branch t1 t2)=Branch (fmap f t1) (fmap f t2)
Diese Instanzdeklaration besagt, daß Tree und nicht Tree a eine
Instanz der Typklasse Functor ist. Dadurch kann die Funktion
map auf verschiedene Behältertypen mit beliebigen Inhaltstypen in
der gleichen Weise angewendet werden.
c○ Horst Hansen Monaden 5
c○ Horst Hansen Monaden 6
Schreibweisen in Haskell
Definition der Typklasse Monad
Die Anwendung von Typklassen auf Typen wird in Haskell genauso
notiert wie die Anwendung von Funktionen auf ihre Argumente.
So wird der Typausdruck T a b parsiert als (T a) b.
Für Funktionen ist (->) der Typkonstruktor, d.h. (->) f g und
f -> g bedeutet dasselbe. Ebenso sind die Typen [] a und [a]
dasselbe. Entsprechendes gilt für die Tupelkonstruktoren (,),
(,,) usw.
Um Fehler in der Anwendung von Typklassen auf Typen prüfen zu
können, ist in Haskell ein Metatypsystem implementiert. Typen von
Typen werden als hier als kind bezeichnet (siehe [HPF99], S.26).
Kommen wir jetzt zur Typklasse Monad zurück.
1 class Monad m where
2 (>>=) :: m a -> (a -> m b) -> m b
3 (>>) :: m a -> m b -> m b
4 return :: a -> m a
5 m >> k = m >>= \_ -> k
Die zwei Basisfunktionen einer Monade sind >>= (gesprochen:
bind) und return.
Die bind-Funktion kombiniert zwei monadische Datenwerte.
Die return-Funktion fügt dem monadischen Behälter einen
Datenwert hinzu.
c○ Horst Hansen Monaden 7
c○ Horst Hansen Monaden 8

Erläuterung der bind-Funktion
do-Syntax
ma >>= \v -> mb kombiniert einen monadischen Behälter ma,
der Werte vom Typ a enthält und eine Funktion, die auf einem
Wert v vom Typ a arbeitet. Sie liefert einen neuen monadischen
Behälter mb als Ergebnis. Das Ergebnis ist somit die Kombination
von ma und mb zu einem neuen monadischen Behälter, der den
Wert b enthält.
Die genaue Bedeutung der bind-Funktion hängt von der konkreten
Monade ab.
Die do-Syntax von Haskell ist durch die folgenden Definitionen
gegeben:
1 do e1 ; e2 = e1 >> e2
2 do p >= \p -> e2
c○ Horst Hansen Monaden 9
c○ Horst Hansen Monaden 10
Quellen
[CK04] Chakravarty, M.M.T., Keller, G.C.: Einführung in die
Programmierung mit Haskell; Pearson Studium, 2004
[HPF99] Hudak, P., Peterson, J., Fasel, J.H.: A Gentle Introduction to
Haskell 98; from somewhere in the web
[OSG08] O’Sullivan, B., Stewart, D., Goerzen, J.: Real World Haskell;
http://book.realworldhaskell.org/read/index.html, 2011
[Wadl95] Wadler, P.: Monads for functional programming; in: LNCS
925, Springer Verlag, 1995
c○ Horst Hansen Monaden 11