Programmieren in Haskell Einstieg in Haskell

Transkript

1 Programmieren in Haskell Einstieg in Haskell Peter Steffen Universität Bielefeld Technische Fakultät Programmieren in Haskell

2 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

3 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

4 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

5 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

6 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

7 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

8 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

9 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

10 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..]) (..) => Programmieren in Haskell

11 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

12 Datentypen Ausdrücke haben Typen: 42 :: Int :: Int 4.2 :: Float True: Bool "Hallo Welt!" :: String bzw. [Char] [1,2,3] :: [Int] 12 Programmieren in Haskell

13 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

14 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 ) Kelvin kelvin_nach_fahrenheit :: Temperatur -> Temperatur kelvin_nach_fahrenheit (Temp t Kelvin) = Temp (t*9/ ) Fahrenheit 14 Programmieren in Haskell

15 Funktionen auf neuen Datentypen Oder etwas eleganter: umrechnen :: Temperatur -> Einheit -> Temperatur umrechnen (Temp t Celsius) Kelvin = Temp (t ) Kelvin umrechnen (Temp t Kelvin) Fahrenheit = Temp (t*9/ ) Fahrenheit umrechnen (Temp 506 Kelvin) Fahrenheit => Temp Fahrenheit umrechnen (Temp (-100) Celsius) Kelvin => Temp Kelvin 15 Programmieren in Haskell

16 Funktionen auf neuen Datentypen Oder etwas eleganter: umrechnen :: Temperatur -> Einheit -> Temperatur umrechnen (Temp t Celsius) Kelvin = Temp (t ) Kelvin umrechnen (Temp t Kelvin) Fahrenheit = Temp (t*9/ ) Fahrenheit umrechnen (Temp 506 Kelvin) Fahrenheit => Temp Fahrenheit umrechnen (Temp (-100) Celsius) Kelvin => Temp Kelvin 15 Programmieren in Haskell

17 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

18 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

19 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

20 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

21 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

22 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

23 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

24 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

25 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

26 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

27 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

28 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

29 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

30 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

31 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

32 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

33 Ihre Aufgabe für diese Woche Alle Beispiele ausprobieren, verändern, wieder ausprobieren Programmieren in Haskell