Fortgeschrittene Techniken der Funktionalen Programmierung Vorlesung vom 03.11.09:
Mehr ¨ uber Monaden
Christoph L¨uth, Dennis Walter Universit¨at Bremen Wintersemester 2009/10
1
Heute gibt’s:
IMonaden, mehrMonaden, und noch mehrMonaden
I Die Monaden der Standardb¨ucherei
I Referenz:http://www.haskell.org/all˙about˙monads/html
2
Fahrplan
ITeil I: Monaden und fortgeschrittene Typen
IEinf¨uhrung, Wiederholung
IZust¨ande, Zustands¨uberg¨ange undIO
IReader/Writer, Nichtdeterminismus, Ausnahmen
IMonadentransformer
ITeil II: Fortgeschrittene Datenstrukturen ITeil III: Nebenl¨aufigkeit
ITeil IV: The Future of Programming
3
Die Identit¨ atsmonade
IDie allereinfachste Monade:
type I d a = a
i n s t a n c e Monad I d where r e t u r n a = a
b=f = f b
4
Fehlermonaden
IErste N¨ahrung:Maybe
IMaybekennt nurNothing, daher strukturierte Fehler:
data E i t h e r a b = L e f t a | Right b type E r r o r a = E i t h e r S t r i n g a i n s t a n c e Monad ( E i t h e r S t r i n g ) where
( Right a )=f = f a ( L e f t l ) =f = L e f t l r e t u r n b = Right b
INachteil: Fester Fehlertyp IL¨osung: Typklassen
5
Die Monade Control.Monad.Error
ITypklasseErrorf¨ur Fehler c l a s s E r r o r a where
noMsg : : a
strMsg : : S t r i n g → a IFehlermonade parametrisiert ¨ubere:
c l a s s (Monad m) ⇒ MonadError e m where t h r o w E r r o r : : e → m a
c a t c h E r r o r : : m a → ( e → m a ) → m a
i n s t a n c e MonadError ( E i t h e r e ) where t h r o w E r r o r = L e f t
( L e f t e ) ‘ c a t c h E r r o r ‘ h a n d l e r = h a n d l e r e a ‘ c a t c h E r r o r ‘ = a
6
Die Zustandsmonade
I
IZustands¨ubergang als Funktion
newtype S t a t e s a = S t a t e {unwrap : : ( s → ( a , s ) )} i n s t a n c e Monad ( S t a t e s ) where
r e t u r n a = S t a t e $ λs → ( a , s )
( S t a t e g )= f = S t a t e ( u n c u r r y g . unwrap f )
INachteil 1:Zustands¨ubergangnicht-strikt(insbesonderelazy)!
IL¨osung:Strikter Zustands¨ubergang—Control.Monad.ST INachteil 2:Zustands¨ubergang≡Funktion
IL¨osung:Typklassen
7
Die Monad Control.Monad.State
ITypklasseStatef¨ur Zustand lesen/schreiben:
c l a s s MonadState m s where get : : m s
put : : s → m ( )
IZustandsmonade parametrisiert ¨uberState:
i n s t a n c e MonadState ( S t a t e s ) s where get = S t a t e $ λs → ( s , s ) put s = S t a t e $ λ → ( ( ) , s )
IAber: manchmalliestman nur, manchmalschreibtman nur. . .
8
Die Lesemonade
IIntuition: Werte der Eingabeelesen und verabeiten.
ILese-Teil der Zustandsmonade
newtype Reader e a = Reader ( e → a ) i n s t a n c e Monad ( Reader e ) where
r e t u r n a = Reader $ λe → a ( Reader r )=f = Reader $
λe → l e t Reader g = f ( r e ) i n g e
IEingabe wirdnichtmodifiziert.
IBeispiel: Lesen ausSymboltabelle(Gegenbeispiel: Datei)
9
Die Monade Control.Monad.Reader
IWie vorher: Abstraktion derLeseoperationen
INeu:LokalerZustand
c l a s s MonadReader e m where ask : : m e
l o c a l : : ( e → e ) → m a → m a i n s t a n c e MonadReader ( Reader e ) where
ask = Reader i d
l o c a l f c = Reader $ λe → runReader c ( f e ) a s k s : : ( MonadReader e m) ⇒ ( e → a ) → m a a s k s s e l = ask = r e t u r n . s e l
10
Die Schreibmonade
IProduziert einen Strom von Werten IKein Zugriff auf geschriebene Werte m¨oglich
IBeispiel: “Logging”
newtype W r i t e r w a = W r i t e r ( a , [w ] ) i n s t a n c e Monad ( W r i t e r w) where
r e t u r n a = W r i t e r ( a , [] )
( W r i t e r ( a ,w) )=f = l e t W r i t e r ( a ’ , w’ ) = f a i n W r i t e r ( a ’ , w++ w’ ) IAbstraktion: auch ¨uberListenvon Ausgabewerten
11
Die Monade Control.Monad.Writer
ITypklasseMonoid: Verallgemeinerte Listen
c l a s s ( Monoid w, Monad m) ⇒ MonadWriter w m where pass : : m ( a , w → w) → m a
l i s t e n : : m a → m ( a , w) t e l l : : w → m ( )
i n s t a n c e MonadWriter ( W r i t e r w) where pass ( W r i t e r ( ( a , f ) ,w) ) = W r i t e r ( a , f w) l i s t e n ( W r i t e r ( a ,w) ) = W r i t e r ( ( a ,w) ,w)
t e l l s = W r i t e r ( ( ) , s )
l i s t e n s : : ( MonadWriter w m) ⇒ (w → w) → m a → m ( a ,w) l i s t e n s f m = do ( a ,w)←m; r e t u r n ( a , f w) c e n s o r : : ( MonadWriter w m) ⇒
(w → w) → m a → m a
c e n s o r f m = pass $ do a←m; r e t u r n ( a , f )
12
Die Listenmonade
IListen sind Monaden:
i n s t a n c e Monad [] where
m=f = concatMap f m
r e t u r n x = [ x ] f a i l s = []
IIntuition:f :: a→[b]Liste der m¨oglichen Resultate
IReihenfolge der M¨oglichkeiten relevant?
13
Der Monade Set
IData.Setsind Monaden:
i n s t a n c e Monad Set where
m=f = Set . u n i o n s ( Set . map f m) r e t u r n x = Set . s i n g l e t o n x
f a i l s = Set . empty
INichtvordefiniert . . .
14
Der Continuationmonade
IAuswertungskontext wird explizit modelliert.
newtype Cont r a =
Cont { runCont : : ( ( a → r ) → r ) }
Irist der Typ der gesamten Berechnung Ia→rist der momentane Kontext
i n s t a n c e Monad ( Cont r ) where r e t u r n a = Cont $ λk → k a ( Cont c )=f = Cont $
λk → c (λa → runCont ( f a ) k )
15
Control.Monad.Cont
IcallCC: GOTO f¨ur funktionale Sprachen
c l a s s (Monad m) ⇒ MonadCont m where c a l l C C : : ( ( a → m b ) → m a ) → m a i n s t a n c e MonadCont ( Cont r ) where
c a l l C C f = Cont $
λk → runCont ( f (λa → Cont $ λ → k a ) ) k
ILiebernichtbenutzen!
16
Exkurs: Was ist eigentliche eine Monade?
IMonade: Konstrukt ausKategorientheorie IMonade∼=(verallgemeinerter) Monoid IMonade: gegeben durchalgebraische Theorien
IOperationen endlicher (beschr¨ankter) Aritit¨at
IGleichungen
IBeispiele:Maybe,List,Set,State, . . . IMonaden in Haskell:computational monads
IStrukturierte Notation f¨urBerechnungsparadigmen
IBeispiel: Rechner mit Fehler, Nichtdeterminismus, Zustand, . . .
17
Kombination von Monaden: Das Problem
IGegeben zweiMonaden:
c l a s s Monad m1 where . . . c l a s s Monad m2 where . . .
IEs gelten weder
i n s t a n c e Monad (m1 (m2 a ) ) i n s t a n c e Monad (m2 (m1 a ) ) IProblem:Monadengesetzegelten nicht.
IL¨osung:N¨achsteVorlesung
18
Zusammenfassung
IMonaden sind praktischeAbstraktion IWir haben kennengelernt:
IFehlermonaden:Maybe,Either,MonadError
IZustandsmonaden:State,ST,IO
ILese/Schreibmonade:ReaderMonad,WriterMonad
INichtdeterminusmus:[a],Data.Set
IExplizite Spr¨unge:Continuation
IWichtigesStrukturierungsmittelf¨ur funktionale Programme IKombination bereitet (noch) Probleme . . .
19
