WS 2011/2012. Robert Giegerich. October 17, 2012

Transkript

1 in in WS 2011/2012 Robert AG Praktische Informatik October 17, 2012

2 Sprechstunden in GZI-Arbeitsraum (V2-240) Tutoren-Sprechstunden (V2-228) lehre/audiws12/#ueb de/gzi-tutoren.html

3 seit 1990 benannt nach dem Logiker Curry, aufbauend auf den Sprachen von ML und Miranda funktional (pure) d.h. keine Behälter, keine Anweisungen, kein vorher-nachher lazy evaluation (alias verzögerte ) polymorph und stark typisiert Typinferenz Layout-sensitiv Die wichtigsten Implementierungen: Hugs (Interpreter), GHC (Compiler) in

4 Bürger erster Klasse in Funktionen gibt es in allen Programmiersprachen. In einer funktionalen Sprache sind Funktionen first class citizens : Funktionen sind den Daten gleichberechtigt. Sie können Argumente von (anderen) Funktionen sein Ergebnisse von (anderen) Funktionen sein anonym oder benannt sein über beliebigen Datentypen definiert werden Funktionen höherer Ordnung ersetzen Kontrollstruktur 1 map :: (a -> b) -> [a] ->[b]

5 in Es folgt eine kurze Zusammenfassung der. Vieles davon wird erst später gebraucht.

6 Schlüsselwörter 1 case class data default deriving do else 2 if import in infix infixl infixr instance 3 let module newtype of then type where _ Vergleich Sprache 21 Scheme 23 C (C89) 32 Java 50 Ada 72 C++ 74 #Keywords in

7 Groß- und Kleinschreibung in Modulname erster Buchstabe großgeschrieben Modulname == Dateiname Datentypnamen: Großgeschrieben Datentyp-Konstrukturen: Großgeschrieben (z.b. Datentype Bool Konstruktoren: True und False Funktionsnamen: Kleingeschrieben Operatorzeichen Infix Sonstige Funktionsnamen: Prefix Prioritäten und Assoziation definierbar

8 Keine (!) Anweisungen keine Statements in keine Wertzuweisung, kein FOR, kein WHILE... da funktionale Programmiersprache Es wird beschrieben, WAS berechnet werden soll, aber nicht WIE. So wie in (1 + f (2)) 3 2 (4 + g(5)). in Ein -Programm besteht im wesentlichen aus einer Menge von Definitionen a la 1 f x y z =... ein Ausdruck der x, y, z benutzt 2 g [] = 0 -- hier mit 3 g ( x: xs) = 1 + g xs -- pattern matching

9 Präfix, Infix, Postfix- in Viele Schreibweisen für Ausdrücke: mathematisch in Präfix 1, f (x, y, z) -1, f x y z Infix x < y, n 2, 2x + 5 x<y, nˆ2, 2*x+5 Postfix n!, f --- Mixfix --- if a then b else c anstatt IfThenElse a b c 3 Grafix 1 y root 3 (1 - (root 2 y)) b a f (x) dx integral a b f

10 Operatoren Boolsche Operatoren vordefiniert: oder && und not Vergleichsoperatoren: < <= == /=... reguläre Funktionen in in Example Hugs> :t (&&) (&&) :: Bool -> Bool -> Bool

11 Beispiel 1 > inbetween a b c = 2 > if a <= b && b <= c then True else False Eleganter 1 > inbetween a b c = a <= b && b <= c Geht s noch eleganter? in 1 inbetween a b c = a <= b <= c 1 allequal. lhs :7:20: 2 Precedence parsing error 3 cannot mix <= [ infix 4] and 4 <= [ infix 4] in the same infix expression

12 Prefix/Infix-Konversion Example Funktionen als Operatoren Operatoren als Funktionen fn konvertiert nach Infix (op) konvertiert nach Prefix Main> Main> (+) Test> div Test> 69 div 3 23 in

13 Prefix/Infix: Prioritäten in Flexible Anwendung von Funktionen Deklaration von Prioritäten möglich meist geeignet vordefiniert Funktionsanwendung in Präfix hat höchste Priorität 1 > f x + g y * 2 ist (f x) + ((g y) *2) 2 3 Achtung bei Definitionen : 4 5 > f ( x: xs) ys = x : f xs ys braucht Klammern!!

14 Bedingter Ausdruck 1 if expr1 then expr2 else expr3 Kein If-Statement! if expr1 then expr2? Fehler! hier wäre der Wert des Ausdrucks im else-fall nicht definiert Vergleichbar mit dem Bedingungsoperator in C/Java: cond_expr? expr2 : expr3 in Example 1 func a b = if a <= b then a else b

15 Case-Ausdruck vielfache Fallunterscheidung statt verschachtelte If-Expressions überall wo ein Ausdruck stehen kann Pattern matching 1 case expr of 2 pat1 guard1 - > expr1 3 pat2 guard2 - > expr2 4 pat3 guard3 - > expr Pattern kann leer sein statt pat True -> gilt auch die Konvention pat -> otherwise als default in

16 Case-Ausdruck in Example 1 > laststr xs = case reverse xs of 2 > [] -> " leer " 3 > (l:ls) l == 1 -> " eins " 4 > (l:ls) l == 2 -> " zwei " 5 > otherwise - > " ganz viele "

17 Sichtbarkeitsbereiche in Alle (modernen) Programiersprachen haben Sichtbarkeitsbereiche (scopes). Jeder Name ist in dem Bereich sichtbar in dem er definiert wurde und in allen darin eingebetteteten Bereichen Scopes in einem Programm sind also verschachtelt. Explizite Regeln gelten für Sichtbarkeit über Modulgrenzen hinweg.

18 Let Expression 1 let decl1 2 decl in expr Example Kann überall dort stehen wo ein Ausdruck stehen kann lokaler Scope (Sichtbarkeitsbereich) 1 > func a b = let square x = x * x 2 > plus a b = a + b 3 > in plus ( square a) ( square b) Versus: 1 > square x = x * x 2 3 > plus a b = a + b 4 5 > func a b = plus ( square a) ( square b) in

19 Where- Example lokale Definitionen bei Funktionsdefinitionen case-ausdrücken Module-Definition... 1 > f x = square x + square x 2 > where 3 > square x = x * x in vs. let Ausdruck notationelle Betonung syntaktischer Zucker where kann nicht überall stehen

20 Where- in Schachtelungen auch möglich: 1 > foo x =... f... 2 > where 3 > f x =... g... 4 > where 5 > g x =...

21 Layout und Abseitsregel -Programme sind whitespace-sensitive Verzicht auf Trennzeichen wie ; {} es gilt die Offside-Rule (Abseitsregel) die Einrückung ist entscheidend explizite Verwendung von ; {} ist möglich Example (Fehler) in 1 > laststr xs = case reverse xs of 2 > [] -> " leer " 3 > (l:ls) l == 1 -> " eins " 4 > (l:ls) l == 2 -> " zwei " 5 > otherwise - > " ganz viele "

22 Layout Definitionen gleicher Stufe stehen in der gleichen Einrücktiefe. Example (korrigiert) 1 > laststr xs = case reverse xs of { 2 > [] -> " leer " ; 3 > (l:ls) l == 1 -> " eins " ; 4 > (l:ls) l == 2 -> " zwei " ; 5 > otherwise - > " ganz viele " } in Example 1 > f x = g x + h x 2 > where { g x = x * x ; h x = x + x } 3 > f x = g x + h x 4 > where g x = x * x 5 h x = x + x

23 Allgemeine Abseitsregel in alle Definitionen eines Scope stehen in der gleichen Einrücktiefe tieferes Einrücken bedeutet Fortsetzung der aktuellen Definitionszeile nach let, where, of, do bestimmt der nächste Buchstabe die neue Einrücktiefe Ausrücken nach links beendet den aktuellen Scope Vorteile?? Nachteile??

24 Fehlerbehandlung in mehrere Möglichkeiten Fehler zu behandeln in Programmen (mindestens 8) einfachster Mechanismus: error Signature: error :: String -> a weitere Mechanismen in folgenden Vorlesungen Example 1 > divide a b = 2 > if b == 0 then error " divide by zero " 3 > else div a b

25 Modul-Aufbau Modulname Imports Definitionen 1 > module Meinmodul 2 > where 3 4 > import Data. List 5 6 > splits n = [ splitat k [1.. n] k < -[1..n -1]] Main> splits 5 [ ( [1 ],[ 2,3,4,5] ), ( [1,2 ],[ 3,4,5] ), ( [1,2,3 ],[ 4,5] ), ( [1,2,3,4 ],[ 5] ) ] in

26 Wächter (Guards) in Funktionsdefinitionen 1 > fn pat1 pat > guard1 = expr1 3 > guard2 = expr2 4 >... syntaktische Zucker für Funktionsdefinitionen ersetzt geschachtelte if-anweisungen guards (Wächter) sind Ausdrücke (vom Typ Bool) in Example 1 howmanyequal n m p 2 (n == m) && (m == p) = 3 3 (n == m) (m == p) (n == p) = 2 4 otherwise = 0

27 Pattern matching Pattern Matching auf natürlichen Zahlen Werten Datentyp-Konstruktoren Joker auf der linken Seite von Funktionsdefinitionen in case-ausdrücken in Example 1 > take :: Int -> [a] -> [a] 2 > take (n +1) (a:as) = a : take n as 3 > take = []

28 Pattern matching in Example 1 > f (a:b:c:d:ds) =... 2 > f (a:as) =... 3 > f (a :[]) =... 4 > f [a] = > g 0 =... 7 > g 1 =... 8 > g _ =...

29 Datentypen Ein Datentyp ist eine Mengen von Werten, worauf Operationen (Funktionen) definiert werden können. Eingebaute Datentypen in sind zum Beispiel: Ganze Zahlen (Integer, Int) Funktionen darauf sind z.b.: +, div, square Fließkommazahlen (Float, Double) +, /, square Wahrheitswerte (Bool): True, False &&, Listen ([a]) ++, reverse, take Zeichen (Char) Zeichenketten (String), wobei String = [Char] in

30 Datentypen in Ausdrücke haben Typen: 1 42 :: Int :: Int :: Float 4 True :: Bool 5 " Hallo Welt!" :: String -- bzw. [ Char ] 6 [1,2,3] :: [ Int ]

31 Datentypen In der Shell (z.b. Hugs) Typ-Inferenz von Ausdrücken: Hugs> :t (1+2) :: Num a => a Hugs> :t (4.2) 4.2 :: Fractional a => a Hugs> :t 2/3 2 / 3 :: Fractional a => a Typen Einschränken: Hugs> (2::Int) / (3::Int) ERROR - Cannot infer instance *** Instance : Fractional Int *** Expression : 2 / 3 in Hugs> (2::Int) div (3::Int) 0

32 Typklassen In sind Typen in Klassen organisiert. Typen sind dabei Instanzen von Klassen. Beispiele für Typklassen Eq Überprüfung auf Gleichheit. In der Klasse Eq sind die Operationen == und /= definiert. Instanzen z.b.: Int, Float, Double, String Ord Ordnungsrelation. In der Klasse Ord sind die Operationen <,>,<=,>= definiert. Instanzen z.b.: Int, Float, Double, String Num Umfasst die numerischen Typen, z.b. Int, Float, Double Operationen: +,-,* Show Werte eines Typs der Instanz der Klasse Show ist, lassen sich ausgeben Z.B. Int, Float, Double, String in

33 Listen : [1,2,3,4] 1:2:3:4:[] Konstruktoren: : (cons) [] (nil) [1..10] Signature: [a], [Int] usw. Main> 1:2:3:4:[] [1,2,3,4] in Example 1 > length :: [a] -> Int 2 > length [] = 0 3 > length (a:as) = 1 + length as

34 Tupel Signatur: ( a1, a2, a3,... ) vordefinierte Funktionen: fst snd... Komponenten können verschiedene Typen haben vs. Liste in Example 1 fst :: (a, b) -> a 2 fst (x, y) = x 3 4 snd :: (a, b) -> a 5 snd (_, y) = y

35 Void in Unit-Datentyp in : () einziges Element: () vergleichbar mit void in C/Java

36 in von Programmen Ausrechnen von einem funktionalen Programm

37 Ausdrücke und Werte in Ausdrücke repräsentieren Werte. Ausdrücke sind zum Beispiel: *7 3 answer 4 reverse [2, 4]

38 Ausdrücke in Ausdrücke können einfach sein oder komplex. Einfach: 1 49 Komplex: 1 square ( 3+4) Definition von square: 1 square :: Int - > Int 2 square x = x * x Die einfachste Form eines Ausdrucks wird Normalform genannt.

39 Reduktion von Ausdrücken Reduktion,, Vereinfachung sind synonyme Begriffe und beschreiben den Prozess, einen Ausdruck in seine einfachste Form (Normalform) zu überführen. Example 1 square :: Int - > Int 2 square x = x * x Reduktion von: square (3+4) in square (3 + 4) => square 7 (+) => 7 * 7 (square) => 49 (*) In : Left-to-right, outermost first (lazy evaluation)

40 Reduktionsvarianten in square wertet aus: Left-to-right, outermost first Alternativ: Left-to-right, innermost first (eager evaluation) non-lazy 1 square (3 + 4) = > (3 + 4) * (3 + 4) ( square ) 2 => 7 * (3 + 4) (+) 3 => 7 * 7 (+) 4 => 49 (*)

41 Reduktionsvarianten in Example 1 take 0 xs = [] 2 take n [] = [] 3 take n (x:xs) = x : take (n -1) xs non-lazy: take 2 [1..] take 2 [1..] => take 2 (1:[2..]) (..) => take 2 (1:2:[3..]) (..) => take 2 (1:2:3:[4..]) (..) =>...