Programmieren in Haskell Wir steigen ein... Programmieren in Haskell 1
Was wir heute machen Umfrage: Wer hat den Hugs ausprobiert? Ausdrücke und Werte Datentypen Funktionen Aufgabe für s Wochenende Programmieren in Haskell 2
Ausdrücke und Werte Ausdrücke repräsentieren Werte. Ausdrücke sind zum Beispiel: 42 6*7 answer reverse ".therdegmu lam raw etsil eseid" let { fib 0 = 1; fib 1 = 1; fib n = fib (n-2) + fib (n-1) } in fib 10 Programmieren in Haskell 3
Ausdrücke können einfach sein oder komplex. Einfach: 49 Komplex: square (3+4) Die einfachste Form eines Ausdrucks wird Normalform genannt. Programmieren in Haskell 4
Reduktion von Ausdrücken Reduktion, Auswertung, Vereinfachung sind synonyme Begriffe und beschreiben den Prozess, einen Ausdruck in seine einfachste Form (Normalform) zu überführen. Beispiel: Mit square :: Int -> Int square x = x * x können wir square (3+4) folgendermaßen reduzieren (das Symbol => verwenden wir, um eine Reduktion zu kennzeichnen): square (3 + 4) => square 7 (+) => 7 * 7 (square) => 49 (*) (Die rechte Spalte benennt die Funktionen, deren Definitionen in der Reduktion verwendet wurden) Programmieren in Haskell 5
Reduktionsvarianten Der obige Weg ist nicht der einzige, um den Ausdruck square (3+4) zu reduzieren. Eine Alternative ist: square (3 + 4) => (3 + 4) * (3 + 4) (square) => 7 * (3 + 4) (+) => 7 * 7 (+) => 49 (*) Programmieren in Haskell 6
Gute und schlechte Reduktionswege Gut (so wird es in Haskell gemacht): take 2 [1..] => take 2 (1:[2..]) (..) => 1:take 1 [2..] (take) => 1:take 1 (2:[3..]) (..) => 1:2:take 0 [3..] (take) => 1:2:[] (take) Programmieren in Haskell 7
Gute und schlechte Reduktionswege Gut (so wird es in Haskell gemacht): take 2 [1..] => take 2 (1:[2..]) (..) => 1:take 1 [2..] (take) => 1:take 1 (2:[3..]) (..) => 1:2:take 0 [3..] (take) => 1:2:[] (take) Schlecht (warum?): take 2 [1..] => take 2 (1:[2..]) (..) => take 2 (1:2:[3..]) (..) => take 2 (1:2:3:[4..]) (..) =>... Programmieren in Haskell 7
Datentypen Datentypen sind Mengen von Werten, zusammen mit auf diesen Werten definierten Operationen (Funktionen). Eingebaute Datentypen in Haskell sind zum Beispiel: Ganze Zahlen (Integer, Int) Funktionen darauf sind z.b.: +, -, square Fließkommazahlen (Float, Double) Wahrheitswerte (Bool) &&, Listen ++, reverse, take Zeichenketten (String) Programmieren in Haskell 8
Ausdrücke haben Typen: 42 :: Int 3 + 4 :: Int "Hallo Welt!" :: String [1,2,3] :: [Int] Programmieren in Haskell 9
Neue Datentypen Wir können auch unsere eigenen Datentypen definieren: data Einheit = Celsius Fahrenheit Kelvin deriving (Eq,Show) data Temperatur = Temp Float Einheit deriving (Eq,Show) Damit können wir zum Beispiel folgenden Ausdruck bilden: Temp 506 Kelvin Programmieren in Haskell 10
Funktionen auf neuen Datentypen Wir können nun zum Beispiel Einheiten umrechnen: celsius_nach_kelvin :: Temperatur -> Temperatur celsius_nach_kelvin (Temp t Celsius) = Temp (t + 273.15) Kelvin kelvin_nach_fahrenheit :: Temperatur -> Temperatur kelvin_nach_fahrenheit (Temp t Kelvin) = Temp (t*9/5-459.67) Fahrenheit Programmieren in Haskell 11
Oder etwas eleganter: umrechnen :: Temperatur -> Einheit -> Temperatur umrechnen (Temp t Celsius) Kelvin = Temp (t + 273.15) Kelvin umrechnen (Temp t Kelvin) Fahrenheit = Temp (t*9/5-459.67) Fahrenheit Programmieren in Haskell 12
Oder etwas eleganter: umrechnen :: Temperatur -> Einheit -> Temperatur umrechnen (Temp t Celsius) Kelvin = Temp (t + 273.15) Kelvin umrechnen (Temp t Kelvin) Fahrenheit = Temp (t*9/5-459.67) Fahrenheit umrechnen (Temp 506 Kelvin) Fahrenheit => Temp 451.13 Fahrenheit umrechnen (Temp (-100) Celsius) Kelvin => Temp 173.15 Kelvin Programmieren in Haskell 12
Typklassen In Haskell sind Typen in Klassen organisiert. Hier ein Ausschnitt der Klassen-Hierarchie: Enum Eq Show Ord / \ / Num / \ / \ Ix Real Fractional / Integral Typen sind Instanzen von Klassen. Programmieren in Haskell 13
Klassendefinitionen Klassendefinitionen sind Vereinbarungen von Schnittstellen. Zum Beispiel: Wenn ein Typ Instanz der Klasse Eq ist, kann ich mich darauf verlassen, daß ich Elemente dieses Typs auf Gleichheit testen kann. Zum Beispiel ist der Typ Int eine Instanz der Klasse Eq; ich kann also zwei Ints auf Gleichheit testen: 3 == 4 => False Und außerdem auf Ungleichheit: 3 /= 4 => True Programmieren in Haskell 14
Die Klasse Eq ist folgendermaßen definiert: class Eq a where (==) :: a -> a -> Bool (/=) :: a -> a -> Bool Wegen deriving Eq können wir automatisch auch Temperaturen vergleichen: Temp 506 Kelvin == Temp 506 Kelvin => True Programmieren in Haskell 15
Die Klasse Eq ist folgendermaßen definiert: class Eq a where (==) :: a -> a -> Bool (/=) :: a -> a -> Bool Wegen deriving Eq können wir automatisch auch Temperaturen vergleichen: Temp 506 Kelvin == Temp 506 Kelvin => True Aber: Temp 506 Kelvin == umrechnen (Temp 506 Kelvin) Fahrenheit => False Programmieren in Haskell 15
Eigene Instanzen definieren Jetzt werden wir die Gleichheit auf Temperaturen selbst definieren. Daher definieren wir den Datentyp Temperatur diesmal ohne deriving Eq: data Temperatur = Temp Float Einheit deriving Show Programmieren in Haskell 16
instance Eq Temperatur where (Temp t Celsius) == (Temp u Celsius) = t == u (Temp t Fahrenheit) == (Temp u Fahrenheit) = t == u (Temp t Kelvin) == (Temp u Kelvin) = t == u (Temp t Kelvin) == (Temp u Fahrenheit) = umrechnen (Temp t Kelvin) Fahrenheit == Temp u Fahrenheit Programmieren in Haskell 17
instance Eq Temperatur where (Temp t Celsius) == (Temp u Celsius) = t == u (Temp t Fahrenheit) == (Temp u Fahrenheit) = t == u (Temp t Kelvin) == (Temp u Kelvin) = t == u (Temp t Kelvin) == (Temp u Fahrenheit) = umrechnen (Temp t Kelvin) Fahrenheit == Temp u Fahrenheit Temp 506 Kelvin == umrechnen (Temp 506 Kelvin) Fahrenheit => True Programmieren in Haskell 17
Eine eigene Show-Instanz Temp 100 Celsius => Temp 100.0 Celsius Temp 451 Fahrenheit => Ein Film von Francois Truffaut Programmieren in Haskell 18
Eine eigene Show-Instanz Temp 100 Celsius => Temp 100.0 Celsius Temp 451 Fahrenheit => Ein Film von Francois Truffaut instance Show Temperatur where show (Temp t Fahrenheit) round t == 451 = "Ein Film von Francois Truffaut" show (Temp t e) = "Temp " ++ show t ++ " " ++ show e Programmieren in Haskell 18
Typkontexte Oft wollen wir uns nicht auf einen Typ festlegen, aber doch Zugehörigkeit zu einer oder mehrerer Klassen verlangen. Zum Beispiel: Anstatt die Funktion max nur auf Ints zu definieren (unsere Funktion maxi vom letzten Mal) maxi :: Int -> Int -> Int maxi n m n >= m = n otherwise = m können wir sie für alle vergleichbaren Typen definieren (Ord a wird Typkontext genannt): max :: Ord a => a -> a -> a max n m n >= m = n otherwise = m Programmieren in Haskell 19
max 2 3 => 3 max "Robert" "Marc" => "Robert" max [1,2,3] [1,2,4] => [1,2,4] Programmieren in Haskell 20
Funktionen Funktionen bilden Eingabewerte auf Ausgabewerte ab. Als Beispiel nochmal die Quadrat-Funktion: square :: Int -> Int square x = x * x square hat ein Argument vom Typ Int (nämlich x), und das Ergebnis ist auch vom Typ Int. Man sagt: "Die Funktion square hat den Typ Int nach Int." Programmieren in Haskell 21
Funktionen können auch mehr als ein Argument haben. Zum Beispiel hat unsere Funktion max zwei Argumente: max :: Ord a => a -> a -> a max n m n >= m = n otherwise = m Man sagt: "Die Funktion max hat den Typ a nach a nach a (mit Kontext Ord a)." Programmieren in Haskell 22
Statt max 5 3 können wir auch (max 5) 3 schreiben. Welchen Typ hat der Ausdruck max 5? Programmieren in Haskell 23
Statt max 5 3 können wir auch (max 5) 3 schreiben. Welchen Typ hat der Ausdruck max 5? Fragen wir den Hugs: Main> :t max 5 max 5 :: (Ord a, Num a) => a -> a Programmieren in Haskell 23
Statt max 5 3 können wir auch (max 5) 3 schreiben. Welchen Typ hat der Ausdruck max 5? Fragen wir den Hugs: Main> :t max 5 max 5 :: (Ord a, Num a) => a -> a max 5 kann als neue Funktion aufgefaßt werden: max 5 => f where f m 5 >= m = 5 otherwise = m Programmieren in Haskell 23
Funktionen höherer Ordnung Funktionen sind first-class values, d.h. sie können Argumente anderer Funktionen sein. Dieses Prinzip wird uns durchgehend begleiten! Als Beispiel hier die Funktion map, die eine weitere Funktion auf die Elemente einer Liste anwendet: map :: (a -> b) -> [a] -> [b] map f [] = [] map f (x:xs) = f x:map f xs Programmieren in Haskell 24
Funktionen höherer Ordnung Funktionen sind first-class values, d.h. sie können Argumente anderer Funktionen sein. Dieses Prinzip wird uns durchgehend begleiten! Als Beispiel hier die Funktion map, die eine weitere Funktion auf die Elemente einer Liste anwendet: map :: (a -> b) -> [a] -> [b] map f [] = [] map f (x:xs) = f x:map f xs Jetzt können wir unsere Funktion max 5 auf eine Liste anwenden: map (max 5) [1,2,7,12,3,20] => [5,5,7,12,5,20] Programmieren in Haskell 24
Oder wir erhöhen jedes Element der Liste um 1: map (+1) [1,2,7,12,3,20] => [2,3,8,13,4,21] Welchen Typ hat (+1)? Programmieren in Haskell 25
Oder wir erhöhen jedes Element der Liste um 1: map (+1) [1,2,7,12,3,20] => [2,3,8,13,4,21] Welchen Typ hat (+1)? (+1) :: Num a => a -> a Programmieren in Haskell 25
Ihre Aufgabe für s Wochenende Alle Beispiele ausprobieren, verändern, wieder ausprobieren... Programmieren in Haskell 26