Deklarative Programmierung

Was bisher geschah
I
deklarative Programmierung
I
I
I
funktionale Programmierung (Haskell):
I
I
I
I
funktional:
Programm: Menge von Termgleichungen, Term
Auswertung: Pattern matching, Termumformungen
logisch:
Programm: Menge von Regeln (Horn-Formeln), Formel
(Query)
Auswertung: Unifikation, Resolution
nebenwirkungsfrei
lazy evaluation (ermöglicht unendliche Datentypen)
kompakte Darstellung
Praktikum: ghci, Prelude, Typen, Hoogle
25
Wiederholung Auswertung
Normalform: nicht-reduzierbarer Ausdruck
Auswertung:
schrittweise Reduktion des Ausdruckes (Ersetzung der
Redexe),
bis Normalform erreicht ist (enthält keinen Redex)
Auswertungsstrategien:
innermost-Reduktion (strikt)
outermost-Reduktion (lazy)
Beispiel:
f :: Int -> Int
f 0 = 1
f (n + 1) = 2 * (f n) + 1
f 3
26
Haskell-Datentypen
einfache Datentypen, z.B.
Int
ganze Zahlen (feste Länge)
Integer ganze Zahlen (beliebige Länge)
Bool
Wahrheitswerte
Char
ASCII-Symbole
Konstruktion zusammengesetzter Datentypen:
I
(kartesisches) Produkt, z.B. Tupel
I
Vereinigung (Fallunterscheidung)
z.B. Aufzählungstypen True, False
I
Rekursion, z.B. Listen, Bäume
I
Potenz, Funktionen
27
Algebraische Datentypen
data Foo = Foo { bar :: Int, baz :: String }
deriving Show
Bezeichnungen:
I
data Foo ist Typname
I
Foo { .. } ist Konstruktor
I
bar, baz sind Komponenten
x :: Foo
x = Foo { bar = 3, baz = "hal" }
Mathematisch: Produkt
Foo = Int × String
28
Datentyp mit mehreren Konstruktoren
Beispiel (selbst definiert)
data T = A { foo :: Int }
| B { bar :: String }
deriving Show
Beispiel (in Prelude vordefiniert)
data Bool = False | True
data Ordering = LT | EQ | GT
Mathematisch: (disjunkte) Vereinigung
Bool = { False } ∪ { True }
29
Fallunterscheidung, Pattern Matching
data T = A { foo :: Int }
| B { bar :: String }
Fallunterscheidung:
f :: T -> Int
f x = case x of
A {} -> foo x
B {} -> length $ bar x
Pattern Matching (Bezeichner n,l werden lokal gebunden):
f :: T -> Int
f x = case x of
A { foo = n } -> n
B { bar = l } -> length l
30
Rekursive Datentypen: Peano-Zahlen
data Nat = Zero
| S Nat
Menge aller Peano-Zahlen
Addition
add :: Nat -> Nat -> Nat
add x Zero = x
add x ( S y ) = S ( add x y )
Beispiel:
add (S (S (S Zero ))) (S (S Zero)) =
S (S (S (S (S Zero))))
Ausführung der Berechnungsschritte (Tafel)
Nat ist mit dieser Addition
assoziativ, kommutativ, add Zero x = x
Nachweis durch strukturelle Induktion (Tafel)
Definition weiterer Operationen: Multiplikation, Potenz
31
Strukturelle Induktion
Induktive Definition strukturierter Daten (rekursive Datentypen):
IA: Basisfälle
IS: rekursive Fälle, Vorschrift zur Konstruktion
zusammengesetzter Daten
Induktive Definition von Funktionen über strukturierten Daten:
IA: Definition des Funktionswertes für Basisfälle
IS: Berechnung des Funktionswertes der
zusammengesetzten Daten aus den Funktionswerten
der Teile
Prinzip der strukturellen Induktion
zum Nachweis einer Aussage A über strukturierte Daten:
IA: Nachweis, dass A für alle Basisfälle gilt
I Hypothese (Voraussetzung): A gilt für Teildaten
IS:
I Behauptung: A gilt für aus Teildaten
zusammengesetzte Daten
I Induktionsbeweis: Nachweis, dass Behauptung
aus Hypothese folgt.
32
Strukturelle Induktion – Beispiele
N : Pni=0 i = n(n + 1)/2
I
∀n ∈
I
Jede Formel aus AL(P) hat wenigstens eine Teilformel.
I
+ und · auf
I
Die Länge der Verkettung zweier Listen ist die Summe der
Längen beider Listen.
I
inorder-Durchquerung jedes binären Suchbaumes ist
sortiert.
I
insert auf binären Suchbäumen erhält
Suchbaum-Eigenschaft.
N sind assoziativ, kommutativ
33