Was bisher geschah. deklarative Programmierung. funktionale Programmierung (Haskell):

Transkript

1 Was bisher geschah deklarative Programmierung funktional: Programm: Menge von Termgleichungen, Term Auswertung: Pattern matsching, Termumformungen logisch: Programm: Menge von Regeln (Horn-Formeln), Formel (Query) Auswertung: Unifikation, Resolution funktionale Programmierung (Haskell): nebenwirkungsfrei lazy evaluation (ermöglicht unendliche Datentypen) kompakte Darstellung 15

2 Haskell-Programme Semantik: Funktion von Eingabe auf Ausgabe keine Variablen, also keine Programmzustände (kein Aufruf-Kontext) Wert jeder Funktion(sanwendung) hängt ausschließlich von den Werten der Argumente ab Syntax: Ausdrücke: Terme z.b. 2 + x * 7 oder double 2 Funktionsdefinition: Gleichung zwischen zwei Ausdrücken z.b. inc x = x + 1 Programm: Liste von Funktionsdefinitionen Ausdruck 16

3 Ausdrücke Ausdruck = Term (Baumstruktur) Jeder Ausdruck hat einen Typ und einen Wert Berechnung des Wertes durch schrittweise Reduktion (Termersetzung) 17

4 Beispiele Ausdruck 7 hat den Typ Int den Wert 7 Ausdruck 3 * hat den Typ Int den Wert? Reduktion: rekursive Berechnung des Wertes 18

5 Funktionsdeklarationen double :: Int -> Int double x = x + x (Typdeklaration) (Funktionsdefinition) Ausdruck double 3 den Typ Int den Wert 6 hat Ausdruck double (double 3) hat den Typ Int den Wert? Ausdruck double hat den Typ Int -> Int den Wert x x + x (mathematische Notation) λx.(x + x) (λ-kalkül) 19

6 Typinferenz Inferenzregel: f :: A B e :: A f e :: B (man bemerke die Analogie zum Modus Ponens) Beispiel: True :: Bool False :: Bool neg :: Bool -> Bool neg b = case b of True -> False False -> True Typ von neg True, neg (neg True) sum [1,2,3] 20

7 Auswertung Normalform: nicht-reduzierbarer Ausdruck Auswertung: schrittweise Reduktion, bis Normalform erreicht Auswertungsstrategien: innermost-reduktion (strikt) outermost-reduktion (lazy) Beispiel: double (double 3) Besonders in Haskell: Termination Auswertungsreihenfolge egal (Konfluenz) 21

8 Definition von Funktionen Fallunterscheidung Rekursion Beispiel: fac n = if n < 1 then 1 else n * (fac (n-1)) zum Vergleich: Ablaufsteuerung in imperativen Sprachen Nacheinanderausführung Verzweigung (Fallunterscheidung) Wiederholung (Iteration) 22

9 Funktionen als Daten f :: Int -> Int f x = 2 * x + 3 äquivalent: Lambda-Ausdruck f = λx.(2x + 3) Funktionsanwendung (Reduktion): f = λx.a fb = A[x B] falls x nicht (frei) in B vorkommt Lambda-Kalkül: Alonzo Church 1936, Henk Barendregt 1984,... Beispiel: A = 2x + 3, B = 1 f = λx.a = λx.(2x + 3) fb = (λx.a)b = λx.(2x + 3)1 = = 5 23

10 Rekursion und Pattern Matching fac :: Int -> Int fac 1 = 1 fac n = n * (fac (n-1)) Wert von fac 4? Wert von fac (-4)? Verbesserungsvorschlag? alternative Darstellung: fac :: Int -> Int fac n = if (n > 1) then n * (fac (n-1)) else 1 noch viel mehr: evolution.html 24

11 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: Produkt, z.b. Tupel Summe (Fallunterscheidung) z.b. Aufzählungstypen True, False Rekursion, z.b. Listen, Bäume Potenz, Funktionen 25

12 Algebraische Datentypen data Foo = Foo { bar :: Int, baz :: String } deriving Show Bezeichnungen: data Foo ist Typname Foo {.. } ist Konstruktor bar, baz sind Komponenten x :: Foo x = Foo { bar = 3, baz = "hal" } Mathematisch: Produkt Foo = Int String 26

13 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) Summe Bool = { False } { True } 27

14 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 f,b werden lokal gebunden): f :: T -> Int f x = case x of A { foo = f } -> f B { bar = b } -> length b 28

15 Rekursive Datentypen: Peano-Zahlen data Nat = Zero S Nat 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 29

16 Datentyp Liste (polymorph) eigentlich: data List a = Nil {} Cons { head :: a, tail :: List a } aber aus historischen Gründen data [a] = [] a : [a] Pattern matching dafür: len :: [a] -> Int len xs = case xs of [] -> 0 (x : xss) ->... Summe der Elemente einer Liste? 30

17 Strukturelle Induktion über Listen app :: [a] -> [a] -> [a] app xs ys = case xs of [] -> ys (x : xss) -> x : (app xss ys) Strukturelle Induktion zum Nachweis von Eigenschaften wie z.b. app xs [] = xs app ist assoziativ, d.h append xs (app ys zs) = app (app xs ys) zs 31

18 Mehr Beispiele Länge der Eingabeliste len :: [a] -> Int len xs = case xs of [] -> 0 (x : xss) -> 1 + len xss jedes Element der Eingabeliste verdoppeln doubles :: [Int] -> [Int] doubles xs = case xs of [] -> [] ( y : ys ) -> ( y + y ) : (doubles ys) is_monoton :: [Int] -> Bool is_monoton xs = case xs of [] -> True [ _ ] -> True (x : y : ys) -> x <= y && is_monoton (y : ys) 32

19 Datentyp Binärbaum (polymorph) data Tree a = Leaf {} Branch { left :: Tree a, key :: a, right :: Tree a } Pattern Matching: f :: Tree a ->.. f t = case t of Leaf {} ->.. Branch { left = l, key = k, right = r } ->.. 33

20 Rekursion über binäre Bäume Anzahl der inneren Knoten count :: Tree Int -> Int count t = case t of Leaf {} -> 0 Branch {} -> count (left t) count (right t) Anzahl der Blätter: leaves :: Tree a -> Int leaves t = case t of Leaf {} ->... Branch {} ->... 34

21 Mehr Beispiele jeden Schlüssel verdoppeln doubles :: Tree Int -> Tree Int doubles t = case t of Leaf {} -> Leaf {} Branch {} ->... inorder :: Tree a -> [a] inorder t = case t of Leaf {} -> [] Branch {} ->... vollständiger binärer Baum der Höhe h: full :: Int -> Tree Int full h = if h > 0 then Branch { left = full (h-1), key = h, right = full (h-1) } else Leaf {} 35

22 Binäre Suchbäume Suchbaum-Eigenschaft: Ein binärer Baum t :: Tree Int ist genau dann ein Suchbaum, wenn seine Knoten in Inorder-Durchquerung aufsteigend geordnet sind. search_tree t = is_monoton (inorder t) Einfügen eines Schlüssels in einen binären Suchbaum: insert :: Int -> Tree Int -> Tree Int insert x t = case t of Leaf {} -> Branch { left = Leaf {}, key = t, right = Leaf {} } Branch {} ->... 36

23 Sortieren durch Einfügen in binäre Suchbäume Einfügen mehrerer Schlüssel in binären Suchbaum: inserts :: [Int] -> Tree Int -> Tree Int inserts xs t = case xs of [] -> t ( x : xss ) ->... Sortieren durch Einfügen in binären Suchbaum: sort :: [Int] -> [Int] sort xs = inorder ( inserts xs Leaf ) 37

24 Strukturelle Induktion über Bäume zum Nachweis von Eigenschaften wie z.b. Einfügen eines Knotens erhält die Suchbaum-Eigenschaft. 38