Grundlagen der Programmierung in Haskell

Vorsemesterkurs InformatikGrundlagen der Programmierung in HaskellSoSe 2013Stand der Folien: April 5, 2013

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelÜbersicht1 Ausdrücke und Typen2 Funktionen3 Rekursion4 Listen5 Paare und TupelVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 2/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelProgrammieren in Haskell (2)In Haskell hat jeder Ausdruck (und Unterausdruck) einen TypTyp = Art des Ausdrucksz.B. Buchstabe, Zahl, Liste von Zahlen, Funktion, . . .Die Typen müssen zueinander passen:Z.B. verboten1 + "Hallo"Die Typen passen nicht zusammen (Zahl und Zeichenkette)Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 4/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelTypenAndere Sichtweise:Typ = Menge von Werten. . . -1421 1000IntegerVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 5/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelTypenAndere Sichtweise:Typ = Menge von Werten Ausdrücken. . . -1421 1000f 10Integer-Werte100+20 . . .1*4*5*10IntegerVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 5/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelTypen (2)Im GHCi Typen anzeigen lassen:Prelude> :type ’C’ ←↪’C’ :: CharSprechweisen:”‘’C’ hat den Typ Char”’”‘’C’ ist vom Typ Char”’”‘’C’ gehört zum Typ Char”’Char ist der Typ in Haskell für Zeichen (engl. Character)Typnamen beginnen immer mit einem GroßbuchstabenVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 6/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelTypen (3)Im GHCi: :set +tführt dazu, dass mit jedem Ergebnis auch dessen Typgedruckt wird.*Main> :set +t ←↪*Main> zwei_mal_Zwei ←↪4it :: Integer*Main> oft_fuenf_addieren ←↪55it :: IntegerVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 7/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelTypen (4)Der Typ Integer stellt beliebig große ganze Zahlen darMan kann Typen auch selbst angeben:Schreibweise Ausdruck::Typ*Main> ’C’::Char ←↪’C’it :: Char*Main> ’C’::Integer ←↪:1:0:Couldn’t match expected type ‘Integer’against inferred type ‘Char’In the expression: ’C’ :: IntegerIn the definition of ‘it’: it = ’C’ :: IntegerVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 8/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelWahrheitswerte: Der Datentyp BoolWerte (Datenkonstruktoren) vom Typ Bool:True steht für ”‘wahr”’False steht für ”‘falsch”’Operationen (Funktionen):Logische Negation: not: liefert True für False und False für TrueLogisches Und: a && b: nur True, wenn a und b zu True auswertenLogisches Oder: a || b: True, sobald a oder b zu True auswertet.*Main> not True ←↪Falseit :: Bool*Main> not False ←↪Trueit :: Bool*Main> True && True ←↪Trueit :: Bool*Main> False && True ←↪Falseit :: Bool*Main> False || False ←↪Falseit :: Bool*Main> True || False ←↪Trueit :: BoolVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 9/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelGanze Zahlen: Int und IntegerDer Typ Int umfasst ganze Zahlen beschränkter Größe(je nach Rechner, z.B. −2 31 bis 2 31 − 1)Der Typ Integer umfasst ganze Zahlen beliebiger GrößeVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 10/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelGanze Zahlen: Int und IntegerDer Typ Int umfasst ganze Zahlen beschränkter Größe(je nach Rechner, z.B. −2 31 bis 2 31 − 1)Der Typ Integer umfasst ganze Zahlen beliebiger GrößeDarstellung der Zahlen ist identisch z.B. 1000Defaulting: Integer, wenn es nötig ist, sonst offenlassen:Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 10/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelGanze Zahlen: Int und IntegerDer Typ Int umfasst ganze Zahlen beschränkter Größe(je nach Rechner, z.B. −2 31 bis 2 31 − 1)Der Typ Integer umfasst ganze Zahlen beliebiger GrößeDarstellung der Zahlen ist identisch z.B. 1000Defaulting: Integer, wenn es nötig ist, sonst offenlassen:Prelude> :type 10001000 :: (Num t) => tPrelude> :set +tPrelude> 10001000it :: IntegerIn etwa 1000 ist vom Typ t, wenn t ein numerischer Typ ist.Genauer: (Num t) => ist eine sog. TypklassenbeschränkungInt und Integer sind numerische Typen (haben Instanzen für Num)Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 10/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelGleitkommazahlenTypen Float und Double (mit doppelter Genauigkeit)Kommastelle wird mit . (Punkt) dargestelltTypklasse dazu: FractionalPrelude> :type 10.5 ←↪10.5 :: (Fractional t) => tPrelude> 10.5 ←↪10.5it :: DoubleBeachte: Das Rechnen mit solchen Kommazahlen istungenau!Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 11/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelZeichen und ZeichenkettenDer Typ Char repräsentiert ZeichenDarstellung: Zeichen in einfache Anführungszeichen, z.B. ’A’Spezielle Zeichen (Auswahl):Darstellung in Haskell Zeichen, das sich dahinter verbirgt’\\’ Backslash \’\’’ einfaches Anführungszeichen ’’\"’ doppeltes Anführungszeichen "’\n’ Zeilenumbruch’\t’ TabulatorZeichenketten: Typ StringDastellung in doppelten Anfühungszeichen, z.B. "Hallo".Genauer ist der Typ String gleich zu [Char]d.h. eine Liste von Zeichen (Listen behandeln wir später)Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 12/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelBeispiel Zeichenketten> :set +t> "Ein \n\’mehrzeiliger\’\nText mit \"Anfuehrungszeichen\"""Ein \n’mehrzeiliger’\nText mit \"Anfuehrungszeichen\""it :: [Char]> putStrLn "Ein \n\’mehrzeiliger\’\nText mit \"Anfuehrungszeichen\""Ein’mehrzeiliger’Text mit "Anfuehrungszeichen"it :: ()Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 13/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelOperatoren auf ZahlenOperatoren auf Zahlen in Haskell:Addition +, Substraktion -, Multiplikation * und Division /Beispiele: 3 * 6, 10.0 / 2.5, 4 + 5 * 4Beim - muss man aufpassen, da es auch für negative Zahlenbenutzt wirdPrelude> 2 * -2 ←↪:1:0:Precedence parsing errorcannot mix ‘*’ [infixl 7] and prefix ‘-’ [infixl 6]in the same infix expressionPrelude> 2 * (-2) ←↪-4Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 14/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelVergleichsoperationenGleichheitstest == undUngleichheitstest /=größer: >, größer oder gleich: >=kleiner: 3*10 == 6*5 ←↪TruePrelude> True == False ←↪FalsePrelude> False == False ←↪TruePrelude> 2*8 /= 64 ←↪TruePrelude> 2+8 /= 10 ←↪FalsePrelude> True /= False ←↪TruePrelude> 5 >= 5 ←↪TruePrelude> 5 > 5 ←↪FalsePrelude> 6 > 5 ←↪TruePrelude> 4 < 5 ←↪TruePrelude> 4 < 4 ←↪FalsePrelude> 4

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelFunktionenFunktionen verwenden, Funktionstypen, Funktionen definierenVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 16/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelFunktionenSei f eine Funktion, die den Rest einer Division mit Rest berechnet.In der Mathematik würde man z.B. schreiben: f(10, 3) = 1Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 17/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelFunktionenSei f eine Funktion, die den Rest einer Division mit Rest berechnet.In der Mathematik würde man z.B. schreiben: f(10, 3) = 1Schreibweise in Haskell: f 10 3 oder auch (f 10 3)Grund: Man darf in Haskell partiell anwenden, z.B. (f 10)Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 17/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelFunktionenSei f eine Funktion, die den Rest einer Division mit Rest berechnet.In der Mathematik würde man z.B. schreiben: f(10, 3) = 1Schreibweise in Haskell: f 10 3 oder auch (f 10 3)Grund: Man darf in Haskell partiell anwenden, z.B. (f 10)Obige Funktion heißt in Haskell: modPassend dazu: div: Ganzzahligen Anteil der Division mit RestPrelude> mod 10 3 ←↪1Prelude> div 10 3 ←↪3Prelude> mod 15 5 ←↪0Prelude> div 15 5 ←↪3Prelude> (div 15 5) + (mod 8 6) ←↪5Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 17/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelPräfix und Infix+, *, . . . werden infix verwendet:zwischen den Argumenten, z.B. 5+6mod, div werden präfix verwendet:vor den Argumenten, z.B. mod 10 3Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 18/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelPräfix und Infix+, *, . . . werden infix verwendet:zwischen den Argumenten, z.B. 5+6mod, div werden präfix verwendet:vor den Argumenten, z.B. mod 10 3Präfix-Operatoren infix verwenden:In Hochkommata setzen ( ⇑ + `´z.B. 10 ‘mod‘ 3Infix-Operatoren präfix verwenden:In runde Klammern setzenz.B. (+) 5 6)Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 18/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelFunktionstypen (1)Auch Funktionen haben einen TypFunktion hat mehrere Eingaben und eine AusgabeJeder der Eingaben und die Ausgabe haben einen TypVerkettung durch ->Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 19/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelFunktionstypen (1)Auch Funktionen haben einen TypFunktion hat mehrere Eingaben und eine AusgabeJeder der Eingaben und die Ausgabe haben einen TypVerkettung durch ->Prelude> :type not ←↪not :: Bool -> BoolPrelude> :type (&&) ←↪(&&) :: Bool -> Bool -> BoolPrelude> :type (||) ←↪(||) :: Bool -> Bool -> Boolnot: Eine Eingabe vom Typ Boolund Ausgabe vom Typ Bool(&&): Zwei Eingaben vom Typ Boolund Ausgabe vom Typ Bool(||): Zwei Eingaben vom Typ Boolund Ausgabe vom Typ BoolVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 19/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelFunktionstypen (2)Allgemein: f erwartet n Eingaben, dann ist der Typ von f:f :: Typ 1}{{}Typ des1. Arguments-> Typ 2}{{}Typ des2. Arguments-> . . . -> Typ n} {{ }Typ desn. Arguments-> in Funktionstypen ist rechts-geklammert(&&) :: Bool -> Bool -> Boolentspricht (&&) :: Bool -> (Bool -> Bool)und nicht (&&) :: (Bool -> Bool) -> BoolDas passt zur partiellen Anwendung:(&&) :: Bool -> (Bool -> Bool)True :: Bool------------------------------------((&&) True) :: (Bool -> Bool)-> Typ n+1} {{ }Typ desErgebnissesVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 20/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelFunktionstypen (3)Typen von mod und div:mod :: Integer -> Integer -> Integerdiv :: Integer -> Integer -> IntegerIn Wirklichkeit:Prelude> :type mod ←↪mod :: (Integral a) => a -> a -> aPrelude> :type div ←↪div :: (Integral a) => a -> a -> aIn etwa: Für alle Typen a die Integral-Typen sind,hat mod den Typ a -> a -> aVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 21/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelFunktionstypen (4)Prelude> :type (==) ←↪(==) :: (Eq a) => a -> a -> BoolPrelude> :type ( a -> BoolPrelude> :type ( a -> BoolPrelude> :type (+) ←↪(+) :: (Num a) => a -> a -> aPrelude> :type (-) ←↪(-) :: (Num a) => a -> a -> aVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 22/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelFunktionstypen (5)Die Typen müssen stets passen, sonst gibt’s einen Typfehler:Prelude> :type notnot :: Bool -> BoolPrelude> not ’C’:1:4:Couldn’t match expected type ‘Bool’ against inferred type ‘Char’In the first argument of ‘not’, namely ’C’In the expression: not ’C’In the definition of ‘it’: it = not ’C’Manchmal “merkwürdige” Fehlermeldung:Prelude> not 5:1:4:No instance for (Num Bool)arising from the literal ‘5’ at :1:4Possible fix: add an instance declaration for (Num Bool)In the first argument of ‘not’, namely ‘5’In the expression: not 5In the definition of ‘it’: it = not 5Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 23/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelFunktionen selbst definierenverdopple x = x + xIn der Mathematik würde man schreiben verdopple(x) = x + xVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 24/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelFunktionen selbst definierenverdopple x = x + xIn der Mathematik würde man schreiben verdopple(x) = x + xAllgemein:funktion Name par 1 . . . par n = Haskell Ausdruckwobeipar i : Formale Parameter, z.B. Variablen x, y, . . .Die par i dürfen rechts im Haskell Ausdruck verwendet werdenfunktion Name muss mit Kleinbuchstaben oder einemUnterstrich beginnenVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 24/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelFunktionen selbst definierenverdopple :: Integer -> Integerverdopple x = x + xIn der Mathematik würde man schreiben verdopple(x) = x + xAllgemein:funktion Name par 1 . . . par n = Haskell Ausdruckwobeipar i : Formale Parameter, z.B. Variablen x, y, . . .Die par i dürfen rechts im Haskell Ausdruck verwendet werdenfunktion Name muss mit Kleinbuchstaben oder einemUnterstrich beginnenMan darf auch den Typ angeben!Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 24/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelFunktion testenPrelude> :load programme/einfacheFunktionen.hs ←↪[1 of 1] Compiling Main ( programme/einfacheFunktionen.hs)Ok, modules loaded: Main.*Main> verdopple 5 ←↪10*Main> verdopple 100 ←↪200*Main> verdopple (verdopple (2*3) + verdopple (6+9)) ←↪84Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 25/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelFallunterscheidung: if-then-elseSyntax: if b then e 1 else e 2verdoppleGerade :: Integer -> IntegerverdoppleGerade x = if even x then verdopple x else xeven testet, ob eine Zahl gerade ist:even x = x ‘mod‘ 2 == 0*Main> :reload ←↪[1 of 1] Compiling Main ( programme/einfacheFunktionen.hs )Ok, modules loaded: Main.*Main> verdoppleGerade 50 ←↪100*Main> verdoppleGerade 17 ←↪17Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 26/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelFallunterscheidung: if-then-else (2)Verschachteln von if-then-else:jenachdem :: Integer -> Integerjenachdem x = if x < 100 then 2*x elseif x Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 27/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelNoch ein Beispielverdoppeln_oder_verdreifachen :: Bool -> Integer -> Integerverdoppeln_oder_verdreifachen b x =if b then 2*x else 3*x*Main> verdoppeln_oder_verdreifachen True 1020*Main> verdoppeln_oder_verdreifachen False 1030verdoppeln mithilfe von verdoppeln_oder_verdreifachen:verdoppeln2 :: Integer -> Integerverdoppeln2 x = verdoppeln_oder_verdreifachen True x-- oder auch:verdoppeln3 :: Integer -> Integerverdoppeln3 = verdoppeln_oder_verdreifachen Trueverdoppeln3: keine Eingabe, Ausgabe ist eine FunktionVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 28/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelHigher-Order FunktionenD.h.: Rückgabewerte dürfen in Haskell auch Funktionen seinAuch Argumente (Eingaben) dürfen Funktionen sein:wende_an_und_addiere f x y = (f x) + (f y)*Main> wende_an_und_addiere verdopple 10 20 ←↪60*Main> wende_an_und_addiere jenachdem 150 3000 ←↪3450Daher spricht man auch von Funktionen höherer Ordnung!Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 29/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelNochmal TypenTyp von wende_an_und_addierewende an und addiere :: (Integer -> Integer) -> Integer -> Integer -> Integerwende an und addiere f x y = (f x) + (f y)Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 30/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelNochmal TypenTyp von wende_an_und_addierewende an und addiere :: (Integer -> Integer)} {{ }Typ von fwende an und addiere f x y = (f x) + (f y)-> Integer} {{ }Typ von x-> Integer} {{ }Typ von y-> Integer} {{ }Typ desErgebnissesVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 30/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelNochmal TypenTyp von wende_an_und_addierewende an und addiere :: (Integer -> Integer) -> Integer -> Integer -> Integerwende an und addiere f x y = (f x) + (f y)Achtung: Im Typ(Integer -> Integer) -> Integer -> Integer -> Integerdarf man die Klammern nicht weglassen:Integer -> Integer -> Integer -> Integer -> Integerdenn das entsprichtInteger -> (Integer -> (Integer -> (Integer -> Integer))).Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 30/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelPolymorphe Typenzweimal_anwenden :: (a -> a) -> a -> azweimal_anwenden f x = f (f x)Da Typvariablen in Haskell erlaubt sind, spricht man vonpolymorphen TypenFür Typvariablen kann man Typen einsetzen!Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 31/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelPolymorphe Typenzweimal_anwenden :: (a -> a) -> a -> azweimal_anwenden f x = f (f x)Da Typvariablen in Haskell erlaubt sind, spricht man vonpolymorphen Typenz.B. a = IntFür Typvariablen kann man Typen einsetzen!zweimal_anwenden :: (a -> a) -> a -> aVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 31/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelPolymorphe Typenzweimal_anwenden :: (a -> a) -> a -> azweimal_anwenden f x = f (f x)Da Typvariablen in Haskell erlaubt sind, spricht man vonpolymorphen Typenz.B. a = IntFür Typvariablen kann man Typen einsetzen!zweimal_anwenden :: (Int -> Int) -> Int -> IntVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 31/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelPolymorphe Typenzweimal_anwenden :: (a -> a) -> a -> azweimal_anwenden f x = f (f x)Da Typvariablen in Haskell erlaubt sind, spricht man vonpolymorphen Typenz.B. a = IntFür Typvariablen kann man Typen einsetzen!zweimal_anwenden :: (Int -> Int) -> Int -> Intz.B. a = Boolzweimal_anwenden :: (a -> a) -> a -> aVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 31/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelPolymorphe Typenzweimal_anwenden :: (a -> a) -> a -> azweimal_anwenden f x = f (f x)Da Typvariablen in Haskell erlaubt sind, spricht man vonpolymorphen Typenz.B. a = IntFür Typvariablen kann man Typen einsetzen!zweimal_anwenden :: (Int -> Int) -> Int -> Intz.B. a = Boolzweimal_anwenden :: (Bool -> Bool) -> Bool -> BoolVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 31/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelPolymorphe Typenzweimal_anwenden :: (a -> a) -> a -> azweimal_anwenden f x = f (f x)Da Typvariablen in Haskell erlaubt sind, spricht man vonpolymorphen Typenz.B. a = IntFür Typvariablen kann man Typen einsetzen!zweimal_anwenden :: (Int -> Int) -> Int -> Intz.B. a = Boolzweimal_anwenden :: (Bool -> Bool) -> Bool -> Boolz.B. a = Char -> Charzweimal_anwenden::((Char->Char)->(Char->Char))->(Char->Char)->(Char->Char)Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 31/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelFormale ParameterGesucht:Funktion erhält zwei Eingaben und liefert"Die Eingaben sind gleich",wenn die beiden Eingaben gleich sind.Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 32/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelFormale ParameterGesucht:Funktion erhält zwei Eingaben und liefert"Die Eingaben sind gleich",wenn die beiden Eingaben gleich sind.Falscher Versuch:sonicht x x = "Die Eingaben sind gleich!"Conflicting definitions for ‘x’In the definition of ‘sonicht’Failed, modules loaded: none.Die formalen Parameter müssen unterschiedliche Namen haben.vergleiche x y =if x == y then "Die Eingaben sind gleich!" else "Ungleich!"Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 32/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelRekursion”‘Wer Rekursion verstehen will, muss Rekursion verstehen.”’Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 33/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelRekursionEine Funktion ist rekursiv, wenn sie sich selbst aufrufen kann.f x y z = ... (f a b c) ...oder z.B. auchf x y z = ... (g a b) ...g x y = ... (f c d e) ...Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 34/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelRekursion (2)Bei Rekursion muss man aufpassen:endlos_eins_addieren x = endlos_eins_addieren (x+1)endlos_eins_addieren 0--> endlos_eins_addieren 1--> endlos_eins_addieren 2--> endlos_eins_addieren 3--> endlos_eins_addieren 4--> ...endlos_eins_addieren 0 terminiert nicht!Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 35/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelRekursion (3)So macht man es richtig:Rekursionsanfang: Der Fall, für den sich die Funktion nichtmehr selbst aufruft, sondern abbrichtRekursionsschritt: Der rekursive AufrufDarauf achten, dass der Rekursionsanfang stets erreicht wird.Beispiel:erste_rekursive_Funktion x =if x

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelRekursion (4)erste_rekursive_Funktion x =if x 0?Testen:*Main> erste_rekursive_Funktion 515*Main> erste_rekursive_Funktion 1055*Main> erste_rekursive_Funktion 1166*Main> erste_rekursive_Funktion 1278*Main> erste_rekursive_Funktion 11Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 37/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelRekursion (5)erste_rekursive_Funktion x =if x

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelRekursion (6)erste_rekursive_Funktion x =if x

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelRekursion (6)erste_rekursive_Funktion x =if x

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelRekursion (7)Warum ist Rekursion nützlich?Man kann damit schwierige Probleme einfach lösen∑Wie geht man vor? (z.B. implementiere f(n) = n i)i=1Rekursionsanfang:Der einfache Fall, für den man die Lösung direkt kennt∑f(0) = 0 i = 0i=0Rekursionsschritt:Man löst ganz wenig selbst, bis das Problem etwas kleiner ist.Das (immer noch große) Restproblem erledigt die Rekursion,∑f(n) =n i = x+ n−1 ∑i = n+f(n − 1) (für x > 0)i=0i=0Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 40/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelRekursion: Türme von Hanoi12. . .n − 1nStartstapel Zielstapel HilfsstapelStartsituationVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 41/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelRekursion: Türme von Hanoi12. . .n − 1nStartstapel Zielstapel HilfsstapelZielsituationVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 41/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelBeispiel n = 3123Startstapel Zielstapel HilfsstapelVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 42/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelBeispiel n = 323Startstapel Zielstapel Hilfsstapel1Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 42/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelBeispiel n = 33 2 1Startstapel Zielstapel HilfsstapelVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 42/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelBeispiel n = 313 2Startstapel Zielstapel HilfsstapelVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 42/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelBeispiel n = 312Startstapel Zielstapel Hilfsstapel3Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 42/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelBeispiel n = 3123Startstapel Zielstapel HilfsstapelVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 42/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelBeispiel n = 31Startstapel Zielstapel Hilfsstapel23Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 42/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelBeispiel n = 3Startstapel Zielstapel Hilfsstapel123keine korrekte LösungVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 42/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelBeispiel n = 3123Startstapel Zielstapel Hilfsstapelzurück zum AnfangVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 42/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelBeispiel n = 3231Startstapel Zielstapel HilfsstapelVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 42/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelBeispiel n = 33 12Startstapel Zielstapel HilfsstapelVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 42/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelBeispiel n = 313 2Startstapel Zielstapel HilfsstapelVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 42/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelBeispiel n = 313 2Startstapel Zielstapel HilfsstapelVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 42/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelBeispiel n = 313 2Startstapel Zielstapel HilfsstapelVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 42/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelBeispiel n = 3123Startstapel Zielstapel HilfsstapelVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 42/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelLösen durch Rekursion: Rekursionanfang1Startstapel Zielstapel Hilfsstapeln = 1: Verschiebe Scheibe von Startstapel auf ZielstapelVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 43/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelLösen durch Rekursion: Rekursionanfang1Startstapel Zielstapel Hilfsstapeln = 1: Verschiebe Scheibe von Startstapel auf ZielstapelVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 43/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelLösen durch Rekursion: Rekursionanfang1Startstapel Zielstapel Hilfsstapeln = 1: Verschiebe Scheibe von Startstapel auf ZielstapelVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 43/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelLösen durch Rekursion: Rekursionsschritt12. . .n − 1nStartstapel Zielstapel HilfsstapelVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 44/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelLösen durch Rekursion: Rekursionsschritt12. . .n − 1nStartstapel Zielstapel Hilfsstapel1. Verschiebe den Turm der Höhe n − 1 rekursiv auf den HilfsstapelVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 44/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelLösen durch Rekursion: Rekursionsschritt12. . .n n − 1Startstapel Zielstapel Hilfsstapel1. Verschiebe den Turm der Höhe n − 1 rekursiv auf den HilfsstapelVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 44/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelLösen durch Rekursion: Rekursionsschritt12. . .n n − 1Startstapel Zielstapel Hilfsstapel2. Verschiebe Scheibe n auf den ZielstapelVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 44/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelLösen durch Rekursion: Rekursionsschritt12. . .n n − 1Startstapel Zielstapel Hilfsstapel2. Verschiebe Scheibe n auf den ZielstapelVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 44/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelLösen durch Rekursion: Rekursionsschritt12. . .n n − 1Startstapel Zielstapel Hilfsstapel3. Verschiebe den Turm der Höhe n − 1 rekursiv auf den ZielstapelVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 44/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelLösen durch Rekursion: Rekursionsschritt12. . .n − 1nStartstapel Zielstapel Hilfsstapel3. Verschiebe den Turm der Höhe n − 1 rekursiv auf den ZielstapelVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 44/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelPseudo-Algorithmusverschiebe(n,start,ziel,hilf)1. Wenn n > 1, dann verschiebe(n-1,start,hilf,ziel)2. Schiebe Scheibe n von start auf ziel3. Wenn n > 1, dann verschiebe(n-1,hilf,ziel,start)Rekursionanfang ist bei n = 1: keine rekursiven AufrufeBeachte: Zwei rekursive Aufrufe pro RekursionsschrittHaskell-Implementierung: SpäterVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 45/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelRekursion, weitere BeispieleBeispiel: n-mal VerdoppelnRekursionsanfang:n_mal_verdoppeln :: Integer -> Integer -> Integern_mal_verdoppeln x n =Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 46/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelRekursion, weitere BeispieleBeispiel: n-mal VerdoppelnRekursionsanfang: n = 0: Gar nicht verdoppelnn_mal_verdoppeln :: Integer -> Integer -> Integern_mal_verdoppeln x n =if n == 0 then xVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 46/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelPattern matching (auf Zahlen)n_mal_verdoppeln :: Integer -> Integer -> Integern_mal_verdoppeln x n =if n == 0 then xelse n_mal_verdoppeln (verdopple x) (n-1)Man darf statt Variablen auch Pattern in der Funktionsdefinitionverwenden, und mehrere Definitionsgleichungen angeben. DiePattern werden von unten nach oben abgearbeitet.n_mal_verdoppeln2 :: Integer -> Integer -> Integern_mal_verdoppeln2 x 0 = xn_mal_verdoppeln2 x n = n_mal_verdoppeln2 (verdopple x) (n-1)Falsch:n_mal_verdoppeln2 :: Integer -> Integer -> Integern_mal_verdoppeln2 x n = n_mal_verdoppeln2 (verdopple x) (n-1)n_mal_verdoppeln2 x 0 = xVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 47/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelGuardsGuards (Wächter): Boolesche Ausdrücke,die die Definition der Funktion festlegenf x1 ... xm| 1. Guard = e1...| n. Guard = enAbarbeitung von oben nach untenErster Guard, der zu True auswertet,bestimmt die Definition.n_mal_verdoppeln3 :: Integer -> Integer -> Integern_mal_verdoppeln3 x n| n == 0 = x| otherwise = n_mal_verdoppeln3 (verdopple x) (n-1)Vordefiniert: otherwise = TrueVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 48/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelDie Error-Funktionn_mal_verdoppeln3 :: Integer -> Integer -> Integern_mal_verdoppeln3 x n| n == 0 = x| otherwise = n_mal_verdoppeln3 (verdopple x) (n-1)Was passiert bei negativem n?Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 49/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelDie Error-Funktionn_mal_verdoppeln3 :: Integer -> Integer -> Integern_mal_verdoppeln3 x n| n == 0 = x| otherwise = n_mal_verdoppeln3 (verdopple x) (n-1)Was passiert bei negativem n?error :: String -> an_mal_verdoppeln4 :: Integer -> Integer -> Integern_mal_verdoppeln4 x n| n < 0 = error "Negatives Verdoppeln verboten!"| n == 0 = x| otherwise = n_mal_verdoppeln4 (verdopple x) (n-1)*Main> n_mal_verdoppeln4 10 (-10)*** Exception:in n_mal_verdoppeln4: negatives Verdoppeln ist verbotenVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 49/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelBeispielIn einem Wald werden am 1.1. des ersten Jahres 10 Rehe gezählt.Der erfahrene Förster weiß, dass sich im Laufe eines Jahres, dieAnzahl an Rehen durch Paarung verdreifacht. In jedem Jahrschießt der Förster 17 Rehe. In jedem 2. Jahr gibt der Förster dieHälfte der verbleibenden Rehe am 31.12. an einen anderen Waldab.Wieviel Rehe gibt es im Wald am 1.1. des Jahres n?Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 50/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelBeispielIn einem Wald werden am 1.1. des ersten Jahres 10 Rehe gezählt.Der erfahrene Förster weiß, dass sich im Laufe eines Jahres, dieAnzahl an Rehen durch Paarung verdreifacht. In jedem Jahrschießt der Förster 17 Rehe. In jedem 2. Jahr gibt der Förster dieHälfte der verbleibenden Rehe am 31.12. an einen anderen Waldab.Wieviel Rehe gibt es im Wald am 1.1. des Jahres n?Rekursionsanfang: Jahr 1, 10 ReheanzahlRehe 1 = 10Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 50/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelBeispielIn einem Wald werden am 1.1. des ersten Jahres 10 Rehe gezählt.Der erfahrene Förster weiß, dass sich im Laufe eines Jahres, dieAnzahl an Rehen durch Paarung verdreifacht. In jedem Jahrschießt der Förster 17 Rehe. In jedem 2. Jahr gibt der Förster dieHälfte der verbleibenden Rehe am 31.12. an einen anderen Waldab.Wieviel Rehe gibt es im Wald am 1.1. des Jahres n?Rekursionsanfang: Jahr 1, 10 ReheRekursionsschritt: Sei k = Anzahl Rehe am 1.1. des Jahres n − 1anzahlRehe 1 = 10anzahlRehe n =anzahlRehe (n-1)Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 50/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelBeispielIn einem Wald werden am 1.1. des ersten Jahres 10 Rehe gezählt.Der erfahrene Förster weiß, dass sich im Laufe eines Jahres, dieAnzahl an Rehen durch Paarung verdreifacht. In jedem Jahrschießt der Förster 17 Rehe. In jedem 2. Jahr gibt der Förster dieHälfte der verbleibenden Rehe am 31.12. an einen anderen Waldab.Wieviel Rehe gibt es im Wald am 1.1. des Jahres n?Rekursionsanfang: Jahr 1, 10 ReheRekursionsschritt: Sei k = Anzahl Rehe am 1.1. des Jahres n − 1{ 3 ∗ k − 17, falls n − 1 kein zweites JahrJahr n:(3 ∗ k − 17)/2, falls n − 1 ein zweites JahranzahlRehe 1 = 10anzahlRehe n = if even (n-1)then (3*(anzahlRehe (n-1))-17) ‘div‘ 2else 3*(anzahlRehe (n-1))-17Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 50/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelBeispiel (2)*Main> anzahlRehe 110*Main> anzahlRehe 213*Main> anzahlRehe 311*Main> anzahlRehe 416*Main> anzahlRehe 515*Main> anzahlRehe 628*Main> anzahlRehe 733*Main> anzahlRehe 882*Main> anzahlRehe 9114*Main> anzahlRehe 10325*Main> anzahlRehe 503626347914090925Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 51/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelLet-Ausdrücke: Lokale DefinitionenanzahlRehe 1 = 10anzahlRehe n = if even (n-1)then (3*(anzahlRehe (n-1))-17) ‘div‘ 2else 3*(anzahlRehe (n-1))-17Mit let:anzahlRehe2 1 = 10anzahlRehe2 n = let k = (3*anzahlRehe2 (n-1))-17in if even (n-1) then k ‘div‘ 2else kVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 52/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelLet-Ausdrücke: Lokale Definitionen (2)Allgemeiner:let Variable1 = Ausdruck1Variable2 = Ausdruck2. . .VariableN = AusdruckNin AusdruckVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 53/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelListen undProgrammieren mit ListenVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 54/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelListenListe = Folge von Elementenz.B. [True, False, False, True, True] und [1,2,3,4,5,6]In Haskell nur homogene Listen erlaubt:Alle Elemente haben den gleichen Typz.B. verboten: [True,’a’,False,2]Prelude> [True,’a’,False,2]:1:6:Couldn’t match expected type ‘Bool’ against inferred type ‘Char’In the expression: ’a’In the expression: [True, ’a’, False, 2]In the definition of ‘it’: it = [True, ’a’, False, ....]Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 55/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelListen: TypAllgemeiner Typ: [a]Das a bezeichnet den Typ der Elementez.B. Liste von Zeichen: Typ [Char] usw.Prelude> :type [True,False][True,False] :: [Bool]Prelude> :type [’A’,’B’][’A’,’B’] :: [Char]Prelude> :type [1,2,3][1,2,3] :: (Num t) => [t]Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 56/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelListen: TypAllgemeiner Typ: [a]Das a bezeichnet den Typ der Elementez.B. Liste von Zeichen: Typ [Char] usw.Prelude> :type [True,False][True,False] :: [Bool]Prelude> :type [’A’,’B’][’A’,’B’] :: [Char]Prelude> :type [1,2,3][1,2,3] :: (Num t) => [t]Auch möglich:*Main> :type [verdopple, verdoppleGerade, jenachdem][verdopple, verdoppleGerade, jenachdem] :: [Integer -> Integer]*Main> :type [[True,False], [False,True,True], [True,True]][[True,False], [False,True,True], [True,True]] :: [[Bool]]Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 56/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelListen erstellenEckige Klammern und Kommas z.B. [1,2,3]Das ist jedoch nur Syntaktischer ZuckerListen sind rekursiv definiert:Typen:”‘Rekursionsanfang”’ ist die leere Liste [] (”‘Nil”’)”‘Rekursionsschritt”’ mit : (”‘Cons”’)x ein Listenelementxs eine Liste (mit n − 1 Elementen)Dann ist x:xs Liste mit n Elementen beginnend mit x undanschließend folgen die Elemente aus xs[1,2,3] ist in Wahrheit 1:(2:(3:[]))[] :: [a](:) :: a -> [a] -> [a]Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 57/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelInterne Darstellung der Listen[1,2,3,4,5] = 1:(2:(3:(4:(5:[])))):1 :2 :3 :4 :5 []Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 58/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelBeispielKonstruiere die Listen der Zahlen n, n − 1 . . . , 1:nbis1 :: Integer -> [Integer]nbis1 0 = []nbis1 n = n:(nbis1 (n-1))*Main> nbis1 0[]*Main> nbis1 1[1]*Main> nbis1 10[10,9,8,7,6,5,4,3,2,1]*Main> nbis1 100[100,99,98,97,96,95,94,93,92,91,90,89,88,87,86,85,84,83,82,81,80,79,78,77,76,75,74,73,72,71,70,69,68,67,66,65,64,63,62,61,60,59,58,57,56,55,54,53,52,51,50,49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32, 31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1]Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 59/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelListen zerlegenVordefiniert:head :: [a] -> a liefert das erste Element einer nicht-leeren Listetail :: [a] -> [a] liefert den Schwanz einer nicht-leeren Liste.null :: [a] -> Bool testet, ob eine Liste leer ist*> head [1,2]1*> tail [1,2,3][2,3]*> head []*** Exception: Prelude.head: empty list*> null []True*> null [4]FalseVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 60/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelBeispielFunktion, die das letzte Element einer Liste liefert.letztesElement :: [a] -> aletztesElement xs = if null xs thenerror "Liste ist leer"elseif null (tail xs) then head xselse letztesElement (tail xs)Main> letztesElement [True,False,True]True*Main> letztesElement [1,2,3]3*Main> letztesElement (nbis1 1000)1*Main> letztesElement [[1,2,3], [4,5,6], [7,8,9]][7,8,9]Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 61/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelListen zerlegen mit PatternInf par 1 . . . par n = rumpfdürfen par i auch sog. Pattern sein.Z.B.eigenesHead [] = error "empty list"eigenesHead (x:xs) = xAuswertung von eigenesHead (1:(2:[]))Das erste Pattern das zu (1:(2:[])) passt (”‘matcht”’) wirdgenommenDies ist (x:xs). Nun wird anhand des Patterns zerlegt:x = 1xs = (2:[])Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 62/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelPattern-MatchPattern []Liste[] :1 :2 :3 :4 :5 []Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 63/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelPattern-MatchPattern []Liste[] :passt nicht1 :2 :3 :4 :5 []Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 63/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelPattern-MatchPattern x:xsListe::xxs1 :2 :3 :4 :5 []Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 63/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelPattern-MatchPattern x:xsListe:x1 xs :x = 1xs = 2:(3:(4:(5:[])))2 :3 :4 :5 []Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 63/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelPattern-MatchPattern x:(y:xs)Liste:x :yxs:1 :2 :3 :4 :5 []Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 63/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelPattern-MatchPattern x:(y:xs)Liste:x 1 :x = 1y = 2xs = 3:(4:(5:[]))2 y xs :3 :4 :5 []Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 63/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelBeispiele: Pattern-MatcheigenesNull [] = TrueeigenesNull (x:xs) = False-- alternativ:eigenesNull2 [] = TrueeigenesNull2 xs = False -- matcht immer!-- falsch!:falschesNull xs = FalsefalschesNull [] = TrueWarning: Pattern match(es) are overlappedIn the definition of ‘falschesNull’: falschesNull [] = ...Ok, modules loaded: Main.*Main> falschesNull [1]False*Main> falschesNull []False*Main> eigenesNull []TrueVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 64/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelLetztes Element mit Pattern:letztesElement2 [] = error "leere Liste"letztesElement2 (x:[]) = xletztesElement2 (x:xs) = letztesElement2 xs(x:[]) passt nur für einelementige Listen!Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 65/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelVordefinierte Listenfunktionen (Auswahl)length :: [a] -> Int berechnet die Länge einer Listetake :: Int -> [a] -> [a] erwartet eine Zahl k und eine Listexs und liefert die Liste der erste k Elemente von xsdrop :: Int -> [a] -> [a] erwartet eine Zahl k und eine Listexs und liefert xs ohne die der ersten k Elemente.(++) :: [a] -> [a] -> [a] ”‘append”’: hängt zwei Listenaneinander, kann infix in der Form xs ++ ys verwendet werden.concat :: [[a]] -> [a] glättet eine Liste von Listen. Z.B.concat [xs,ys] ist gleich zu xs ++ ys.reverse :: [a] -> [a] dreht die Reihenfolge der Elemente einerListe um.Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 66/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelNochmal Strings"Hallo Welt" ist nur syntaktischer Zucker für[’H’,’a’,’l’,’l’,’o’,’ ’,’W’,’e’,’l’,’t’]bzw.’H’:(’a’:(’l’:(’l’:(’o’:(’ ’(:’(W’:(’e’:(l’:(’t’:[]))))))))))*Main> head "Hallo Welt"’H’*Main> tail "Hallo Welt""allo Welt"*Main> null "Hallo Welt"False*Main> null ""True*Main> letztesElement "Hallo Welt"’t’Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 67/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelFunktionen auf StringsZ.B.words :: String -> [String]: Zerlegt eine Zeichenkettein eine Liste von Wortenunwords :: [String] -> String: Macht aus einer Listevon Worten einen einzelnen String.lines :: String -> [String]: Zerlegt eine Zeichenkettein eine Liste von ZeilenanzahlWorte :: String -> IntanzahlWorte text = length (words text)Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 68/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelPaare und TupelPaare in Haskell: (e1,e2) z.B. (1,’A’)Die Typen der Komponenten dürfen verschieden sein.Main> :type ("Hallo",True)("Hallo",True) :: ([Char], Bool)Main> :type ([1,2,3],’A’)([1,2,3],False) :: (Num t) => ([t], Char)*Main> :type (letztesElement, "Hallo" ++ "Welt")(letztesElement, "Hallo" ++ "Welt") :: ([a] -> a, [Char])Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 69/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelPaare und Tupel (2)Zugriffsfunktionen:fst :: (a,b) -> aElement.snd :: (a,b) -> b*Main> fst (1,’A’)1*Main> snd (1,’A’)’A’*Main>nimmt ein Paar und liefert das linkeliefert das rechte Element eines Paares.Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 70/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelPattern-Match auf PaareneigenesFst (x,y) = xeigenesSnd (x,y) = ypaarSumme (x,y) = x+yVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 71/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelTupelWie Paare, aber mit mehr Komponenten.*Main> :set +t*Main> (’A’,True,’B’)(’A’,True,’B’)it :: (Char, Bool, Char)*Main> ([1,2,3],(True,’A’,False,’B’),’B’)([1,2,3],(True,’A’,False,’B’),’B’)it :: ([Integer], (Bool, Char, Bool, Char), Char)Auch hier kann man Pattern verwenden:erstes_aus_vier_tupel (w,x,y,z) = w-- usw.viertes_aus_vier_tupel (w,x,y,z) = zVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 72/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelTürme von Hanoi in Haskell12. . .n − 1nStartstapel Zielstapel Hilfsstapel⇒12. . .n − 1nStartstapel Zielstapel HilfsstapelPseudo-Algorithmus:verschiebe(n,start,ziel,hilf)1. Wenn n > 1, dann verschiebe(n-1,start,hilf,ziel)2. Schiebe Scheibe n von start auf ziel3. Wenn n > 1, dann verschiebe(n-1,hilf,ziel,start)Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 73/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelModellierung in HaskellStapel sind durchnummeriert(am Anfang start = 1, ziel = 2, hilf = 3)Funktion hanoi erhältZahl n = Höhe des Stapels der verschoben werden solldie drei StapelAusgabe: Liste von Zügen.Ein Zug ist ein Paar (x, y)= Schiebe oberste Scheibe vom Stapel x auf Stapel yVorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 74/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelDie Funktion hanoi-- Basisfall: 1 Scheibe verschiebenhanoi 1 start ziel hilf = [(start,ziel)]-- Allgemeiner Fall:hanoi n start ziel hilf =-- Schiebe den Turm der Hoehe n-1 von start zu hilf:(hanoi (n-1) start hilf ziel) ++-- Schiebe n. Scheibe von start auf ziel:[(start,ziel)] ++-- Schiebe Turm der Hoehe n-1 von hilf auf ziel:(hanoi (n-1) hilf ziel start)Starten mitstart_hanoi n = hanoi n 1 2 3Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 75/76

Ausdrücke und Typen Funktionen Rekursion Listen Paare und TupelEin Beispiel*Main> start_hanoi 4[(1,3),(1,2),(3,2),(1,3),(2,1),(2,3),(1,3),(1,2),(3,2),(3,1),(2,1),(3,2),(1,3),(1,2),(3,2)]Vorkurs Informatik SoSe 2013 (04) Grundlagen der Programmierung in Haskell 76/76