Deklarative Programmierung

Was bisher geschah
◮ Algebraische Datentypen
◮ Typklassen und Instanzen
◮ strukturelle Induktion
◮ Rekursionsschemata
◮ Funktionen höherer Ordnung
◮ Monaden
103

Wiederholung Monaden
◮ Datentyp mit Grundoperationen
class Monad m where
return :: a -> m a
( >>= ) :: m a -> (a -> m b) -> m b
◮ Axiome (Monaden-Gesetze)
(return x) >>= f == f x
m >= return x == m
( m >>= f) >>= g == m >>= (\ x -> f x >>= g)
104

Beispiele
◮ Listen (Nichtdeterminismus)
instance Monad [] where
return = \ x -> [x]
m >>= f = concat ( map f m )
◮ Maybe
data Maybe a = Nothing | Just a
instance Monad Maybe where
return = \ x -> Just x
m >>= f = case m of
Nothing -> Nothing
Just x -> f x
◮ IO
data World = ...
data IO = World -> World
data IO a = IO { World -> (a, World) }
Anwendung:
do cs

Übersetzer für Programme
Höhere Programmiersprachen (z.B. Java, Haskell, C) erfordern
Übersetzung von Quell- in Maschinen- oder Byte-Code
Beispiel: Übersetzung von Java-Programmen
Quellcode
↓
Zwischendarstellung
↓
Java-Bytecode
Übersetzung in zwei Phasen:
1. Analyse-Phase (Front-End):
Transformation des Quellcodes in eine
Zwischendarstellung
2. Synthese-Phase (Back-End):
Transformation der Zwischendarstellung in Java-Bytecode
106

Analyse-Phase
Quellcode Scanner −→
Folge von Token Parser −→
Syntaxbaum
lexikalische Analyse (Scanner)
lineare Analyse des Quelltextes, Aufteilung in
Einheiten (Token)
z.B. Schlüsselwörter, Bezeichner, Zahlen
reguläre Sprachen, endliche Automaten
syntaktische Analyse (Parser)
hierarchische Struktur des Quelltextes
z.B. Ausdrücke, Verzweigungen, Schleifen
kontextfreie Sprachen, Kellerautomaten
semantische Analyse Annotationen im Syntaxbaum,
z.B. Typprüfungen
107

Einsatz ähnlicher Methoden
◮ Übersetzung von Daten zwischen verschiedenen Formaten
◮ Verarbeitung von Domain-spezifischen Sprachen
◮ Textformatierung
◮ kontextabhängige Hilfe in Entwicklungsumgebungen
◮ statische Analyse zur Fehlersuche in Programmen
◮ Interpreter
◮ graphische Editoren (z.B. für UML-Diagramme) mit
Programmerzeugung
108

Parser
Eingabe:
Ausgabe:
Beispiele:
String (Liste von Char)
Syntaxbaum o.Ä.
◮ arithmetische und logische Ausdrücke
◮ HTML-Code im Web-Browser
◮ Haskell-Code in GHC / GHCI
type Parser = String -> Tree
parse :: Parser
i.A. nur teilweise Verarbeitung der Eingabe
type Parser = String -> (Tree, String)
Ergebnis:
◮ Syntaxbaum o.Ä. des verarbeiteten Teiles der Eingabe
◮ unverarbeiteter Teil der Eingabe
109

Nichtdeterminismus
Behandlung (temporär) uneindeutiger Ableitungen
mehrdeutige Grammatiken, z.B. verschiedene Ableitungen für
5 − 3 − 2
E ::= n | E − E
mit n ∈ N
Nichtdeterministische Ausgabe (Ergebnisliste)
type Parser = String -> [(Tree, String)]
Ergebnis:
Liste möglicher Syntaxbäume
◮ []: Fehler
◮ [ x ]: eindeutig interpretierbar (Erfolg)
◮ [ x, y, ..
]: mögliche Interpretationen
110

Typabstraktion
Verschiedene Typen von „Eingaben“ c und „Syntaxbäumen“ a
data Parser c a = Parser ( [c] -> [(a, [c])] )
parse :: Parser c a -> [c] -> [(a, [c])]
parse ( Parser f ) s = f s
(oft Char für c)
A Parser for Things
is a functions from Strings
to Lists of Pairs
of Things and Strings!
111

Parser
◮ Elementare Parser
◮ Operationen zur Kombination von Parsern:
◮ sequentielle Kombination
◮ parallele Kombination (Auswahl)
◮ Iteration
112

Elementare Parser
◮ return (immer erfolgreich und eindeutig)
return :: a -> Parser c a
return v = Parser $ \x -> [(v, x)]
◮ reject (nie erfolgreich)
reject :: Parser c a
reject = Parser $ \_ -> []
◮ item (vearbeitet das erste Symbol der Eingabe)
item :: Parser c c
item = Parser $ \x -> case x of
[] -> []
(x : xs) -> [( x, xs )]
113

Anwendung
parse :: Parser String a -> String -> [(a, String )]
parse p ein = p ein
Beispiele:
◮ parse (return 1) "abc"
◮ parse reject "abc"
◮ parse item "abc"
◮ parse item ""
114

Test des ersten Symbols
◮ satisfy (akzeptiert das erste Symbol, falls es die
Bedingung pred erfüllt)
satisfy :: (c -> Bool) -> Parser c c
satisfy pred = do
x c -> Parser c c
expect c = satisfy ( == c )
Beispiele:
◮ parse (expect ’a’) "abc"
◮ parse (expect ’a’) ""
◮ parse (expect ’b’) "abc"
◮ parse (satisfy isDigit) "1a4"
115

Sequentielle Verknüpfung
Verkettung von Sprachen: L ◦ L ′ = {uv | u ∈ L ∧ v ∈ L ′ }
seq :: Parser c a -> ( a -> Parser c b) -> Parser c b
kennen wir schon als bind-Operation für Monaden
>>= :: Parser c a -> ( a -> Parser c b) -> Parser c b
p >>= f = Parser $ \ s -> do
( v, t ) >= ( \v1 -> p2 >>= \v2 -> ...
(\vn -> return (f v1 v2 ... vn))...)
oder in do-Notation:
do v1

parse (parens item) "(r)"
parse (parens p) "(abcd)" 117
Beispiele
p :: Parser Char (Char, Char)
p = do x

Parallele Verknüpfung
Vereinigung von Sprachen: L ∪ L ′
() :: Parser c a -> Parser c a -> Parser c a
p q = Parser $ \ s ->
( parse p s ) ++ ( parse q s )
Beispiel:
s :: Parser Char ()
s = do { expect ’a’ ; s ; expect ’b’ ; s }
return ()
parse (do s ; eof) "abab"
118

Iteration
bekannt aus LV Theoretische Informatik:
L ∗ = {ε} ∪ L +
L + = L ◦ L ∗
many :: Parser c a -> Parser c [a]
many p = many1 p return []
many1 :: Parser c a -> Parser c [a]
many1 p = do
x

Akzeptanz formaler Sprachen
s :: Parser Char ()
akzeptiert alle von der Grammatik mit den Regeln
S → aSbS | ε
erzeugten Wörter
s = do { expect ’a’ ; s ; expect ’b’ ; s }
return ()
parse (do s ; eof) "abaabb"
120

Arithmetische Ausdrücke
Grammatik (mit Operator-Präferenzen):
E ::= P(+P) ∗
P ::= F (∗F ) ∗
F ::= (E) | nat
mit Parsec-Bibliothek ( import Text.Parsec)
summe :: Parsec String () Integer
summe = do
xs