Funktionale Programmierung. Das Funktionale Quiz. Das Funktionale Quiz. Das Funktionale Quiz

Transkript

1 Funktionale Programmierung Das Funktionale Quiz Nenne eine Gemeinsamkeit zwischen Typklassen und OO-Klassen Das Funktionale Quiz Das Funktionale Quiz Nenne einen Unterschied zwischen Typklassen und OO-Klassen Ist es möglich, ein Haskell-Programm mit Modulen in ein Haskell-Programm ohne Module umzuformen? Ja, mittels Umbenennung 1-7

2 Themen heute Lazy Programming Lazy Evaluation Parserkombinatoren Listen unendlicher Länge Lazy Evaluation: Auswertungsstrategie für Haskell Darauf aufbauend: Techniken zur Programmierung Auswertungsstrategie Beispiel Bis jetzt: Wert eines Ausdrucks durch Vereinfachen und Ersetzen mittels Gleichungen Reihenfolge bis jetzt nicht festgelegt Für Implementierung aber notwendig (Strategie) Wünschenswert: Finde Normalform, wenn sie existiert trues = True:trues take 0 l = [] take n (x:xs) = x:(take (n-1) xs) take 2 trues ==> [True,True] Reduktionsreihenfolge die Normalform findet: take 2 trues = take 2 True:trues = True:take (2-1) trues = True:take 1 True:trues = True:True:take (1-1) trues = True:True:take 0 trues = True:True:[] 8-11

3 Lazy Evaluation Gefahr Ausdrücke werden eventuell mehrfach ausgewertet Zugrundeliegende Idee: Werte Argumente nicht aus Beim Pattern-Matching Parameter nur so weit auswerten, bis Muster passt/nicht passt Findet Normalform, wenn sie existiert double x = x + x double (9-3) = (9-3) + (9-3) = 6 + (9-3) = = 12 Für das Ergebnis egal, in der Praxis untragbar Lösung: Beim Ersetzen der Parameter anstatt der Argumente nur Zeiger auf Argumente einsetzen. Repräsentation als Graph Keine doppelte Auswertung Mit Zeigern werden Ausdrücke nicht mehr als Baum (Terme) repräsentiert, sondern als Graph Zeiger werden automatisch dereferenziert add3 x = x + 3 add3 5 = + 3 = 8 Somit wird jedes Argument nur einmal ausgewertet: double (9-3) = + = + = 12 5 Wenn Zeiger vereinfacht werden muss, Ziel vereinfachen: (9-3) 6 add3 (7-6) = + 3 = + 3 = 4 (7-6)

4 Beschreibung von Lazy-Evaluation Funktionsanwendung Betrachte allgemeinste Funktionsdefinition: Nach Art des Ausdrucks: 1. Funktionsanwendung 2. Operatoren und sonstige Syntax 3. Geschachtelte Funktionsanwendung f p1... pk g1 = e1... otherwise = eo v1 a1,1... = r1 -- oder v1 = r1... f q1... qk Auswertung von Funktionsanwendung f a1... ak Drei Aspekte der Funktionsanwendung 1.1 Pattern-Matching Ziel: Gleichung auswählen Schritte zum Funktionswert: 1.1. Gleichung auswählen über Pattern-Matching 1.2. Zweig auswählen mittels Guards 1.3. Lokale Definitionen berücksichtigen Vorgehen: Argumente a1... ak jeweils so weit auswerten, bis klar ist, ob sie auf p1... pk passen Falls ja, erste Gleichung auswerten Andernfalls mit zweiter Gleichung fortfahren 16-19

5 Beispiel: Pattern-Matching 1.2. Guards f :: [Int] -> [Int] -> Int f [] ys = 0 f (x:xs) [] = 0 f (x:xs) (y:ys) = x + y Auswertung von f [1.. 3] [5.. 9]: f (1:[ ]) [5.. 9] Gl. passt nicht f (1:[ ]) (5:[ ]) Gl. passt nicht Gl. passt Ziel: Zweig einer Gleichung auswählen Vorgehen: Parameter durch Zeiger auf Argumente ersetzen Guards von oben nach unten auswerten, bis erster True ergibt Rechte Seite (mit lokalen Definitionen) auswerten Beispiel: Guards max a b c a >= b && a >= c = a b >= c = b True = c max (51-2) (5*7) 23 >= && >= = >= = True = *7 23 >= && >= = >= = True = 49 5*7 23 >= && >= = >= = True = Beispiel Guards True&& >= = >= = True = True && True = >= = True = True = >= = True =

6 1.3. Lokale Definitionen Beispiel: Lokale Definitionen Ziel: Ausdruck mit lokalen Definitionen auswerten Vorgehen: Ausdruck auswerten Rechte Seite einer Definition auswerten, wenn Variable benötigt wird Lokale Definitionen bleiben also erhalten - Graph mittels Namen double x = xx xx = x + x double 5 Auswertung: xx {xx = + } 5 xx {xx = 10} Operatoren und sonstige Syntax 3. Geschachtelte Funktionsaufrufe Argumente der Operatoren auswerten je nach Operator: in Haskell definierbar ( &&...) oder strikt (z.b. arithmetische Operatoren) oder so lazy wie möglich ( ==, :,...) Lambda-Ausdrücke wie Funktionen mit Namen case wie Pattern-Matching oben Vorgehen: Von außen nach innen f e1 (g e2) wertet f 1 (g e2) aus Von rechts nach links f e1 + g e2 wertet erst f e1 dann g e2 aus 24-27

7 Parser-Kombinatoren mittels Lazy-Evaluation Parser Kombinator: Geschlossener Ausdruck type Parse a b = [a] -> [(b, [a])] Bezug zur Lazy-Evaluation: Grammatiken enthalten oft Alternativen und Sequenzen. Mit Lazy-Evaluation stoppt der Parser, sobald feststeht, dass eine Alternative erfüllt ist oder das erste Element einer Folge nicht passt. "Backtracking" Dabei: [a]: Eingabe (b,[a]): Ergebnis und restliche Eingabe [(b,[a])]: Liste verschiedener Möglichkeiten, leer wenn Parser gescheitert ist Scheitert immer none :: Parser a b none inp = [] Einfache Parser Liest nichts, liefert Argument succeed :: b -> Parser a b succeed val inp = [(val,inp)] Liest genau t token :: Eq a => a -> Parse a a token t (x:xs) t==x = [(t,xs)] otherwise = [] token t [] = [] Einfache Parser Liest Zeichen, das Präsikat erfüllt spot :: (a -> Bool) -> Parse a a spot p (x:xs) p x = [(x,xs)] otherwise = [] spot p [] = [] Alternative alt :: Parse a b -> Parse a b -> Parse a b alt p1 p2 inp = p1 inp ++ p2 inp Sequenz zweier Parser (>*>) :: Parse a b -> Parse a c -> Parse a (b,c) (>*>) p1 p2 inp = [((y,z),rem2) (y,rem1) <- p1 inp, (z,rem2) <- p2 rem1 ] 28-31

8 Einfache Parser Einstiegspunkt in den Parser Wandelt Ergebnis um build :: Parse a b -> (b -> c) -> Parse a c build p f inp = [ (f x,rem) (x,rem) <- p inp ] Sequenz einer Liste list :: Parse a b -> Parse a [b] list p = (succeed []) `alt` ((p >*> list p) `build` convert) convert = uncurry (:) Parser anwenden, erste Möglichkeit zurückgeben toplevel :: Parse a b -> [a] -> b toplevel p inp = case results of [] -> error "parse unsuccessful" _ -> head results results = [ found (found,[]) <- p inp ] Listen unendlicher Länge Erweiterung der Listennotation Lazy Evaluation macht Beschreibung unendlicher Datenstrukturen möglich Zwei Aspekte: Erzeugen ones :: [Int] ones = 1:ones Konsumieren addfirsttwo :: [Int] -> Int addfirsttwo (x:y:xs) = x + y addfirsttwo ones = 2 Schlusselement weglassen ergibt unendlich lange Liste Liste aller Zahlen ab 3: [3..] Liste aller ungeraden Zahlen ab 3: [3,5..] Pythagoreische Tripel pythagtriples = [ (x,y,z) z <- [2..], y <- [2.. z-1], x <- [2.. y-1], x*x + y*y == z*z] 32-35

9 Liste aller Primzahlen Folge von Pseudo-Zufallszahlen Idee: Streiche aus der Liste aller Zahlen die Vielfachen der bereits bekannten Primzahlen heraus primes = sieve [2..] sieve (x:xs) = x : sieve [ y y <- xs, y `mod` x > 0] Die ersten 6 Primzahlen: take 6 primes ==> [2,3,5,7,11,13] Lineare Kongruenzmethode: Lineare Funktion anwegendet auf Vorgänger liefert neuen Wert nextrand :: Int -> Int nextrand n = (multiplier*n + increment) `mod` modulus randomsequenze :: Int -> [Int] randomsequenze = iterate nextrand iterate :: (a -> a) -> a -> [a] iterate f x = x : iterate f (f x) Folge von Pseudo-Zufallszahlen seed = multiplier = increment = modulus = randomsequenze seed = [17489,59134,9327,52468,...] Auf bestimmten Bereich skalieren: scalesequence :: Int -> Int -> [Int] -> [Int] scalesequence s t = map scale scale n = n 'div' denom + s range = t-s+1 denom = modulus 'div' range scalesequence (randomsequenze seed) = [42,49,41,48,...] 36-38