Grundlagen der Programmierung 2 [1.5ex] Klausur zu Teil 1

Themen
Funktionales Programmieren in Haskell
Grundlagen der Programmierung 2
Rekursive Funktionen (direkt rekursiv, rekursiv, verschränkt rekursiv)
Auswertung (normale, applikative und verzögerte Reihenfolge)
Klausur zu Teil 1: Themen und Anmerkungen
Auswertungsprozesse (iterativ, endrekursiv, linear rekursiv, . . . )
David Sabel
Gültigkeitsbereiche, freie & gebunde Variablen, λ- & Let-Ausdrücke
(rekursive) Listenprogrammierung und Pattern Matching
Listenfunktionen (map, filter, concat, reverse, take, drop, length, . . . )
List Comprehensions
Benutzer-definierte Datentypen
Sommersemester 2014
Rekursive Datentypen insbes. Bäume und Listen
Typen und Typisierung
1
Grundlagen der Programmierung 2 Themen Teil 1
Themen
Auswertung Typisierung Pattern-Matching Parserkombinatoren
– 2/12 –
Auswertungsreihenfolgen
Sei fun definiert als:
Compilerbau
fun x = if x <= 3 then x * x else x + x
Compiler: 6 Phasen
Lexikalische Analyse, Syntaktische Analyse, Semantische Analyse,
Zwischencodeerzeung, Codeoptimierung, Coderzeugung
Werte fun (2+1) in normaler Reihenfolge aus:
fun (2+1)
D
Syntaktische Analyse:
Kontextfreie Grammatiken, Herleitungen (links/rechts),
Parsemethoden
Top-Down und Bottom-Up-Parser
Rekursiv-absteigende Parser, rekursiv-prädiktive Parser,
Shift-Reduce-Parser
Parserkombinatoren in Haskell
−
→ if ((2+1) <= 3) then (2+1) * (2+1) else (2+1) + (2+1)
A
−
→ if (3 <= 3) then (2+1) * (2+1) else (2+1) + (2+1)
A
−
→ if True then (2+1) * (2+1) else (2+1) + (2+1)
I
→
− (2+1) * (2+1)
A
−
→ 3 * (2+1)
Zwischencode: Stackmaschine und deren Programme
A
−
→3 * 3
A
−
→9
Grundlagen der Programmierung 2 Themen Teil 1
Auswertung Typisierung Pattern-Matching Parserkombinatoren
– 3/12 –
Grundlagen der Programmierung 2 Themen Teil 1
Auswertung Typisierung Pattern-Matching Parserkombinatoren
– 4/12 –
Auswertungsreihenfolgen (2)
Auswertungsreihenfolgen (3)
Sei fun definiert als:
Sei fun definiert als:
fun x = if x <= 3 then x * x else x + x
fun x = if x <= 3 then x * x else x + x
Werte fun (2+1) in verzögerter Reihenfolge aus:
Werte fun (2+1) in applikativer Reihenfolge aus:
fun (2+1)
fun (2+1)
D
−
→ if ((2+1) <= 3) then (2+1) * (2+1) else (2+1) + (2+1)
--x---x---x---x---x--
A
−
→ fun 3
D
A
−
→ if (3 <= 3) then 3 * 3 else 3 + 3
−
→ if (3 <= 3) then 3 * 3 else 3 + 3
x
x
x
x
x
A
−
→ if True then 3 * 3 else 3 + 3
A
I
−
→ if True then 3 * 3 else 3 + 3
→
− 3 * 3
I
A
→
− 3 * 3
−
→9
A
−
→9
Grundlagen der Programmierung 2 Themen Teil 1
Auswertung Typisierung Pattern-Matching Parserkombinatoren
– 5/12 –
Typisierung
Grundlagen der Programmierung 2 Themen Teil 1
Auswertung Typisierung Pattern-Matching Parserkombinatoren
– 6/12 –
Typisierung
Typisiere (map filter)
map :: (a -> b) -> [a] -> [b], filter
:: (c -> Bool) -> [c] -> [c]
| {z } | {z } |
{z
}
|{z} | {z }
σ
τ
ρ
t
s
und γ((a -> b)) = γ((c -> Bool) -> [c] -> [c])
| {z }
|
{z
}
σ
ρ
(map filter) ::γ([a] -> [b])
| {z }
|
{z
}
τ
(s t)
s :: σ → τ, t :: ρ und γ(σ) = γ(ρ)
(s t) :: γ(τ )
wobei γ der Unifikator für σ und τ ist.
Berechne Typsubsitution γ mit Unifikation
·
(a -> b) = (c -> Bool) -> [c] -> [c]
·
·
a = (c -> Bool), b = [c] -> [c]
·
b = [c] -> [c]
a 7→ (c -> Bool)
a 7→ (c -> Bool), b 7→ [c] -> [c]
γ([a] -> [b]) = [c -> Bool] -> [[c] -> [c]]
Grundlagen der Programmierung 2 Themen Teil 1
Auswertung Typisierung Pattern-Matching Parserkombinatoren
– 7/12 –
Grundlagen der Programmierung 2 Themen Teil 1
Auswertung Typisierung Pattern-Matching Parserkombinatoren
– 8/12 –
Pattern-Matching bei Listen
Parserkombinatoren
Was macht fun?
Welchen Typ hat fun?
Rekursionsfall
Idee dabei:
fun (x:((y,(z:zs)):xs)) = z:(fun xs)
fun _
= []
baue Parser durch Zusammensetzen von Parsern
Basisfall
(falls das Pattern nicht matcht)
Parser-Typ
(x:((y,(z:zs)):xs))
type Parser s a = [s] -> [([s],a)]
erstes
Restliste
Listenelement
erstes
zweites
Listenelement Listenelement erste
Paarkomponente
Liste von Möglichkeiten (Mehrdeutigkeiten)
Restliste
zweite
Paarkomponente
Restliste
Eingabe
Resteingabe
erkanntes Ergebnis
fun nimmt von jedem 2.Listenelement von der 2.Paarkomponente
das erste Listenelement. Typ: fun :: [(a,[b])] -> [b]
Grundlagen der Programmierung 2 Themen Teil 1
Auswertung Typisierung Pattern-Matching Parserkombinatoren
– 9/12 –
Parserkombinatoren
Grundlagen der Programmierung 2 Themen Teil 1
Auswertung Typisierung Pattern-Matching Parserkombinatoren
– 10/12 –
Parserkombinatoren
A::= aaAA::= aaAparseA = aa parseAparseA = aa parseAparseA = (symbol ’
| b
| b
| b
| b
| (symbol ’
Minimale Menge von Kombinatoren:
Ein Zeichen erkennen:
symbol :: Char -> Parser Char Char
Sequenzkombinator:
<*> :: Parser s a -> Parser s b -> Parser s (a,b)
pro Nichtterminal eine Parser-Funktion
Alternativkombinator:
<|> :: Parser s a -> Parser s a -> Parser s a
Parseergebnis manipulieren:
<@ :: Parser s a -> (a ->
ersetze Nichtterminal durch die Funktion
ersetze ::= durch =
b) -> Parser s b
erkennen der Terminale:
verwende symbol-Parser
Parser nacheinander ausführen
Grundlagen der Programmierung 2 Themen Teil 1
Auswertung Typisierung Pattern-Matching Parserkombinatoren
– 11/12 –
Sequenzkombinator <*> einfügen
Grundlagen der Programmierung 2 Themen Teil 1
Auswertung Typisierung Pattern-Matching Parserkombinatoren
– 12/12 –