Programmieren in Haskell Einstieg in Haskell Peter Steffen Universität Bielefeld Technische Fakultät 24.10.2008 1 Programmieren in Haskell
Was wir heute machen Umfrage: Wer hat den Hugs ausprobiert? Ausdrücke und Werte Datentypen Funktionen Aufgabe für diese Woche 2 Programmieren in Haskell
Ausdrücke und Werte Ausdrücke repräsentieren Werte. Ausdrücke sind zum Beispiel: 42 6*7 answer reverse ".therdegmu lam raw etsil eseid" 3 Programmieren in Haskell
Ausdrücke Ausdrücke können einfach sein oder komplex. Einfach: 49 Komplex: square (3+4) Definition von square: square :: Int -> Int square x = x * x Die einfachste Form eines Ausdrucks wird Normalform genannt. 4 Programmieren in Haskell
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) 5 Programmieren in Haskell
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 (*) In Haskell wird allerdings die erste Reduktionsvariante gewählt. 6 Programmieren in Haskell
Listen Die leere Liste: [] Eine Liste mit zwei Elementen: [1,2] Der Operator : hängt ein Element vor eine Liste: 1:[] => [1] 1:2:[] => [1,2] Die unendliche Liste: [1..] 7 Programmieren in Haskell
Funktionen auf Listen Die Funktion take nimmt die ersten n Elemente von einer Liste: take 0 xs = [] take n (x:xs) = x : take (n-1) xs Die Funktion drop verwirft die ersten n Elemente einer Liste: drop 0 xs = xs drop n (x:xs) = drop (n-1) xs 8 Programmieren in Haskell
Gute und schlechte Reduktionswege Definition von take: take 0 xs = [] take n (x:xs) = x : take (n-1) xs 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) 9 Programmieren in Haskell
Gute und schlechte Reduktionswege Definition von take: take 0 xs = [] take n (x:xs) = x : take (n-1) xs Schlecht (warum?): take 2 [1..] => take 2 (1:[2..]) (..) => take 2 (1:2:[3..]) (..) => take 2 (1:2:3:[4..]) (..) =>... 10 Programmieren in Haskell
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): True, False &&, Listen ++, reverse, take Zeichen (Char) Zeichenketten (String), wobei String = [Char] 11 Programmieren in Haskell
Datentypen Ausdrücke haben Typen: 42 :: Int 3 + 4 :: Int 4.2 :: Float True: Bool "Hallo Welt!" :: String bzw. [Char] [1,2,3] :: [Int] 12 Programmieren in Haskell
Neue Datentypen Wir können auch unsere eigenen Datentypen definieren: data Einheit = Celsius Fahrenheit Kelvin data Temperatur = Temp Float Einheit deriving (Eq,Show) deriving (Eq,Show) Damit können wir zum Beispiel folgenden Ausdruck bilden: Temp 506 Kelvin :: Temperatur 13 Programmieren in Haskell
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 14 Programmieren in Haskell
Funktionen auf neuen Datentypen 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 15 Programmieren in Haskell
Funktionen auf neuen Datentypen 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 15 Programmieren in Haskell
Typklassen In Haskell 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 16 Programmieren in Haskell
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 17 Programmieren in Haskell
Typklasse Eq 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 18 Programmieren in Haskell
Typklasse Eq 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 18 Programmieren in Haskell
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 19 Programmieren in Haskell
Eigene Instanzen definieren 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 20 Programmieren in Haskell
Eigene Instanzen definieren 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 20 Programmieren in Haskell
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 max 2 3 => 3 max "Robert" "Marc" => "Robert" max [1,2,3] [1,2,4] => [1,2,4] 21 Programmieren in Haskell
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. 22 Programmieren in Haskell
Funktionen 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). 23 Programmieren in Haskell
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 square auf eine Liste anwenden: map square [1,2,7,12,3,20] => [1,4,49,144,9,400] 24 Programmieren in Haskell
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 square auf eine Liste anwenden: map square [1,2,7,12,3,20] => [1,4,49,144,9,400] 24 Programmieren in Haskell
Funktionen höherer Ordnung 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)? (+) :: Num a => a -> a -> a (+1) :: Num a => a -> a 25 Programmieren in Haskell
Funktionen höherer Ordnung 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)? (+) :: Num a => a -> a -> a (+1) :: Num a => a -> a 25 Programmieren in Haskell
map mit Strings map :: (a -> b) -> [a] -> [b] map f [] = [] map f (x:xs) = f x:map f xs Die Funktion map funktioniert auch mit Listen von Strings: map reverse ["Programmieren","in","Haskell"] => ["nereimmargorp","ni","lleksah"] Der Typ von map hier: map :: (String -> String) -> [String] -> [String] 26 Programmieren in Haskell
map Die Funktion length :: [a] -> Int berechnet die Länge einer Liste: length [] = 0 length (x:xs) = 1 + length xs Ein weiteres Beispiel für map: map length ["Programmieren","in","Haskell"] => [13,2,7] Der Typ von map hier: map :: (String -> Int) -> [String] -> [Int] 27 Programmieren in Haskell
Ihre Aufgabe für diese Woche Alle Beispiele ausprobieren, verändern, wieder ausprobieren... 28 Programmieren in Haskell