Manuel M. T. Chakravarty Gabriele C. Keller Einführung in die Programmierung mit Haskell

Transkript

1 Manuel M. T. Chakravarty Gabriele C. Keller Einführung in die Programmierung mit Haskell ein Imprint von Pearson Education München Boston San Francisco Harlow, England Don Mills, Ontario Sydney Mexico City Madrid Amsterdam

2 Kapitel 3 Grundlegende Kontrollstrukturen und Typen»Man findet stets, dass sich ein funktionierendes komplexes System aus einem funktionierenden einfachen System entwickelt hat.«anonym Die Funktionen, die wir bislang definiert haben, waren auf Grundoperationen beschränkt, z. B. die Inkrementierung einer gegebenen Zahl. In diesem Kapitel werden etwas kompliziertere Funktionen besprochen und grundlegende Listenoperationen kurz dargestellt. 3.1 Programme werden aus Modulen gebildet Für gewöhnlich besteht ein Programm aus einer Vielzahl von Funktions- und Typdefinitionen. Offensichtlich ist es nicht ratsam, all dies in einer einzigen Datei zu speichern. Moderne Programmiersprachen bieten daher Möglichkeiten zur Strukturierung von Programmen, indem sie zulassen, dass verwandte Definitionen in logischen Einheiten zusammengefasst und in getrennten Dateien gespeichert werden. In Haskell werden diese Einheiten Module genannt. Sehen wir uns die folgende Definition eines Haskell-Moduls namens Simple an: Beispielmodul Manuel M. T. Chakravarty, Juli 2000 Dies ist ein einfaches Beispiel für eine Moduldefinition module Sample where Quadratwurzel einer gegebenen Zahl berechnen square :: Int -> Int square x = x * x Überprüfen, ob alle drei gegebenen Zahlen gleich sind threeequal :: Int -> Int -> Int -> Bool threeequal a b c = (a == b) && (b == c)

3 26 Kapitel 3 Grundlegende Kontrollstrukturen und Typen Das Modul beginnt mit dem Kopf, d. h. einem Kommentar, der eine einzeilige Beschreibung des Moduls, den Autor und das Erstellungsdatum enthält und den Zweck des Moduls kurz beschreibt. Die erste Quelltextzeile beginnt mit dem Schlüsselwort module, dem der Name des Moduls, das Schlüsselwort where und die zum Modul gehörigen Definitionen folgen. Beachten Sie, dass Modulnamen im Gegensatz zu Funktions- oder Variablennamen mit einem Großbuchstaben beginnen müssen. In Haskell gibt es ein spezielles Modul namens Prelude.hs, das beim Start von GHCi automatisch geladen wird. Das Modul Prelude enthält alle Funktionen, die in Haskell vordefiniert sind, z. B. +, length usw. Da wir mit einfachen, kurzen Programmen beginnen, fügen wir fürs Erste alle Funktionsdefinitionen eines Programms in ein einziges Modul ein. Später erklären wir, wie man komplexere Programme mithilfe von Modulen strukturieren kann. Dies ist ein zentrales Thema in der Softwareentwicklung, und Module spielen bei der Strukturierung umfangreicher Softwaresysteme eine wichtige Rolle. Wir kommen auf dieses Thema später zurück. 3.2 Verzweigungen im Programmablauf Bislang haben alle unsere Programme bedingungslos dieselben Berechnungen durchgeführt Wahlmöglichkeiten werden durch bedingte Anweisungen umgesetzt Wie können wir eine Funktion mit der Definition max :: Int -> Int -> Int implementieren, die das größere ihrer beiden Argumente zurückgibt; d. h. sowohl für den Ausdruck max 5 2 als auch für den Ausdruck max 2 5 soll das Ergebnis 5 berechnet werden, für max 1 7 das Ergebnis 7 etc.? Für zwei zufällig gewählte Zahlen x und y soll maxxy das Ergebnis x liefern, wenn x >= y, andernfalls soll y zurückgegeben werden. Dies kann in Haskell durch einen so genannten Bedingungsausdruck oder If-then-else- Ausdruck repräsentiert werden: if (Bedingung) then (Wert, wenn die Bedingung wahr ist) else (Wert, wenn die Bedingung falsch ist)

4 3.2 Verzweigungen im Programmablauf 27 Nun können wir max folgendermaßen implementieren: max :: Int -> Int -> Int max x y = if x >= y then x else y Sehen wir uns jetzt die Berechnung von max 5 2 an max 5 2 if 5 >= 2 then 5 else 2 if True then 5 else 2 5 Bedingte Anweisungen sind ein wichtiger Bestandteil der Programmierung, weil sie es uns ermöglichen, abhängig von verschiedenen Eingabewerten unterschiedliche Berechnungen durchzuführen. Es folgt ein weiteres Beispiel: signum :: Int -> Int signum x = if x < 0 then -1 else if x == 0 then 0 else Funktionsdefinitionen mit Seitenbedingungen Das Verschachteln von bedingten Anweisungen führt, wie wir in der obigen Definition von signum sehen, zu schlecht lesbaren Programmen. Daher ermöglichen manche Programiersprachen als alternative Syntax die Verwendung von Funktionsdefinitionen mit Seitenbedingungen. signum :: Int -> Int signum x x < 0 = -1 x == 0 = 0 x > 0 = 1 signum 7 (1) 1 Hier sind drei Zwischenschritte zu berechnen: 7 < 0 False 7 == 0 False 7 > 0 True Schließlich können wir die Definition von max wie folgt mithilfe von Funktionen mit Seitenbedingungen neu formulieren: max :: Int -> Int -> Int max x y x >= y = x otherwise = y Die Wahl der Schreibweise ist dem persönlichen Geschmack des Programmierers überlassen.

5 28 Kapitel 3 Grundlegende Kontrollstrukturen und Typen 3.3 Zuweisungen Mit einer Zuweisung wird einem Wert ein Name zugewiesen. Nachfolgend kann über diesen Namen auf den Wert Bezug genommen werden. Beispielsweise können wir nach der Zuweisung pi = einfach pi statt angeben Zuordnung von Namen und Werten Wir können den neu eingeführten Namen in einer anderen Funktionsdefinition verwenden: pi :: Float pi = circlearea :: Float -> Float circlearea radius = pi * radius * radius Gelegentlich müssen wir einen Namen definieren, der nur in innerhalb einer Funktion verwendet wird. In diesem Fall sollten wir eine lokale Variablenzuweisung benutzen. Beispiel: pi :: Float pi = circlearea' :: Float -> Float circlearea' diameter = pi * radius * radius where radius = diameter / 2.0 Diese Funktion wird folgendermaßen berechnet: circlearea' 6.0 pi * radius * radius where radius = 6.0 / 2.0 pi * radius * radius where radius =3.0 pi*3.0*3.0 pi * *

6 3.4 Tupel: Kombinationen verschiedener Datenelemente Tupel: Kombinationen verschiedener Datenelemente Wir haben gesehen, dass einer Funktion mehrere Werte übergeben werden, aber noch nicht, dass eine Funktion mehrere Werte zurückgeben kann. Dies lässt sich mithilfe von Tupeln erreichen: addmul :: Int -> Int -> (Int, Int) addmul xy = (x + y, x * y) Mit einem Tupel werden mehrere Komponenten (im obigen Beispiel zwei Werte vom Typ Int, also ganze Zahlen) zu einem Wert zusammengefasst. Dieser zusammengesetzte Wert kann wie eine Einheit bearbeitet und als Wert von einer Funktion zurückgegeben werden. Die Bildung eines zusammengesetzten Werts ist jedoch nur die eine Seite der Medaille. Wir brauchen auch eine Methode zum Zerlegen dieser Werte. Hierzu verwenden wir eine Notation, die ein Gegenstück zur Notation der Tupelbildung darstellt: fstfromintpair :: (Int, Int) -> Int fstfromintpair (x, y) = x sndfromintpair :: (Int, Int) -> Int sndfromintpair (x, y) = y Im Argument von fstfromlntpair nehmen wir nicht über eine Variable auf das zusammengesetzte Argument als Ganzes Bezug. Stattdessen zerlegen wir das Wertepaar in seine Komponenten x und y. Wenn wir addmul und fstfromlntpair kombinieren, erhalten wir: fstfromintpair (addmul 56) fstfromintpair (5 + 6, 5 * 6) fstfromintpair (11, 30) Beispiel: Punkte Tupel können nicht nur zur Rückgabe mehrerer Ergebniswerte eingesetzt werden, sondern auch zur Darstellung von Datenelementen, die sich nicht durch einen Wert eines grundlegenden Datentyps repräsentiert lassen. Ein schönes Beispiel hierfür sind die Punkte in einem zweidimensionalen kartesischen Koordinatensystem, die durch ein Paar ganzzahliger Werte beschrieben werden können. Damit wir nicht jedes Mal, wenn wir den Typ eines Punkts angeben, die wenig informative Angabe (Int, Int) wiederholen müssen, können wir den neuen Typnamen Point einführen (dies ähnelt der Einführung von Namen für häufig verwendete Werte, die weiter oben erläutert wurde): type Point = (Int, Int)

7 30 Kapitel 3 Grundlegende Kontrollstrukturen und Typen Mit dieser Definition können wir einige einfache Operationen mit Punkten definieren: Ursprung des Koordinatensystems origin :: Point origin = (0, 0) Einen gegebenen Punkt nach rechts verschieben moveright :: Point -> Int -> Point moveright (x, y) distance = (x + distance, y) Einen gegebenen Punkt nach oben verschieben moveup :: Point -> Int -> Point moveup (x, y) distance = (x, y + distance) Beispiel: Farbpunkte Wenn wir die Punkte um das Merkmal Colour (Farbe) erweitern, tritt eine weitere wichtige Eigenschaft der Tupel zu Tage: Die Komponenten von Tupeln können unterschiedlichen Typs sein. Wenn wir die Farbwerte in Worten beschreiben, also jeweils durch eine Zeichenfolge (String) repräsentieren, erhalten wir folgende Definition: Farben werden durch Zeichenfolgen beschrieben type Colour = String Neuer Name für den Typ, der Farbpunkte repräsentiert type ColourPoint = (Int, Int, Colour) Diese Definition lässt folgende Operationen mit Farbpunkten zu: Ursprung des Koordinatensystems in einer gegebenen Farbe origin :: Colour -> ColourPoint origin colour = (0, 0, colour) Einen Farbpunkt vertikal und horizontal verschieben move :: ColourPoint -> Int -> Int -> ColourPoint move (x, y, colour) xdistance ydistance = (x + xdistance, y + ydistance, colour) Abstand zwischen zwei Farbpunkten berechnen distance :: ColourPoint -> ColourPoint -> Float

8 3.4 Tupel: Kombinationen verschiedener Datenelemente 31 distance (xl, yl, colourl) (x2, y2, colour2) = sqrt (inttofloat (dx * dx + dy * dy)) where dx = x2 xl dy = y2 - yl Beachten Sie, dass wir in der letzten Definition eine where-klausel verwenden, um die Ausdrücke x2 - xl und y2 yl nicht wiederholen zu müssen. Die Hilfsfunktion intto Float ist wie folgt definiert: inttofloat :: Int -> Float inttofloat x = frominteger (tointeger x) Die beiden Funktionen frominteger und tointeger sind in Prelude vordefiniert und erleichtern Umwandlungen zwischen verschiedenen Typen numerischer Werte Wichtige Symmetrien in Haskell Wenn wir die Syntax der Werte und Typen von Tupel vergleichen, stellen wir fest, dass sie einander entsprechen. Betrachten Sie folgendes Beispiel: (10, 15, "green") :: (Int, Int, String) Wenn wir die Werte 10, 15 und "green" durch ihre jeweiligen Typen Int, Int und String ersetzen, erhalten wir den Typ des Tupels. Überdies gibt es eine Parallele zwischen der Bildung eines Terms und der Zerlegung des Terms. Betrachten Sie folgendes Beispiel: startpoint = (0, 0, "black") colourofpoint (x, y, colour) = colour Wenn wir die Komponenten der Tupelkonstruktion (0, 0, "black") durch Variablennamen (hier x, y, colour) ersetzen, erhalten wir das Muster, das zur Zerlegung des entsprechenden Tupels eingesetzt werden kann Einige Tupel mit speziellen Namen In der folgenden Tabelle sind einige Tupeltypen und ihre Namen aufgeführt: # Ausdruck Name 0 () Unit 1 nicht definiert nicht definiert 2 (x 1, x 2 ) Paar

9 32 Kapitel 3 Grundlegende Kontrollstrukturen und Typen 3.5 Listen: Viele Werte desselben Typs Tupel bieten die Möglichkeit, eine feste Anzahl von Werten unterschiedlichen Typs zu kombinieren. In vielen Anwendungen muss man jedoch in der Lage sein, zusammengesetzte Typen zu bearbeiten, die eine unterschiedliche Anzahl von Elementen eines einzigen Typs enthalten können. Zu diesem Zweck gibt es Listen. oddnumbers :: Int -> [Int] oddnumbers maxnumber = [1, 3..maxNumber] Die Anzahl der von dieser Funktion zurückgegebenen Werte hängt vom Argument ab, im Gegensatz zur weiter vorn vorgestellten Funktion addmul, bei der nur der Rückgabewert, aber nicht die Anzahl der Rückgabewerte von der Eingabe abhing. Betrachten Sie folgendes Beispiel: oddnumbers 10 [1, 3, 5, 7, 9] oddnumbers 15 [1, 3, 5, 7, 9, 11, 13, 15] Der Unterschied zwischen Tupel und Listen wird deutlich, wenn man ihre Typdefinitionen vergleicht, beispielsweise und # Ausdruck Name 3 (x 1, x 2, x 3 ) Tripel 4 (x 1, x 2, x 3, x 4 ) Quadrupel 5 (x 1, x 2, x 3, x 4, x 5 ) Quintupel n (x 1,, x n ) n-tupel (1, 2, "green") :: (Int, Int, String) [1, 2, 3, 4] :: [Int] Die Anzahl der Komponenten wird in der Typdefinition eines Tupels explizit angegeben, in der Typdefinition einer Liste dagegen nicht. Folglich können die Elemente von Tupeln heterogen sein, während die Elemente von Listen homogen sein müssen Nützliche Listenfunktionen Werte werden in eckige Klammern eingeschlossen: [4, 2, 6, 7, 2] ["red", "green", "blue"] [x, y, z]

10 3.5 Listen: Viele Werte desselben Typs 33 Wir können einer gegebenen Liste am Anfang ein weiteres Element hinzufügen: "yellow" : ["red", "green", "blue"] ["yellow", "red", "green", "blue"] Mit dem Operator : können nur Elemente am Listenanfang hinzugefügt werden. Daher gilt: ["red", "green", "blue"] : "yellow" Fehler! Mit dem Operator ++ können zwei Listen zusammengefügt werden: [4, 2, 3] ++ [3, 1, 2, 7] [4, 2, 3, 3, 1, 2, 7] Mit dem Operator!! können wir ein beliebiges Element ausgeben, das an einer bestimmten Position der Liste steht. [0, 1, 2, 3]!! 2 2 (Die Zählung des Listenindex beginnt bei 0!) Mit den beiden Funktionen head und tail kann eine Liste in das erste Element bzw. die übrigen Elemente unterteilt werden: head [0, 1, 2, 3] 0 tail [0, 1, 2, 3] [1, 2, 3] Die Länge einer Liste ermitteln wir mit length: length [0, 1, 2, 3] 4 Mit sum und product können wir die Elemente einer Liste addieren bzw. multiplizieren: sum [0, 1, 2, 3] 6 product [1, 2, 3, 4] 24 Wie können wir "yellow" mithilfe dieser Funktionen am Ende der Liste ["red", "green", "blue"] einfügen? Den Operator : können wir hierzu nicht verwenden. Wir müssen ++ folgendermaßen benutzen: ["red", "green", "blue"] ++ ["yellow"] Beachten Sie die eckigen Klammern um "yellow", mit denen eine Liste gebildet wird. Wir packen "yellow" also in eine aus einem Element bestehende Liste, die wir dann an die Liste ["red", "green", "blue"] anhängen.

11 34 Kapitel 3 Grundlegende Kontrollstrukturen und Typen Unterschiede zwischen Listen und Tupeln Da Listen und Tupel häufig verwechselt werden, geben wir im Folgenden einen Überblick über die Unterschiede zwischen Listen und Tupeln. Tupel haben die folgenden Eigenschaften: Feste Größe, d. h. feste Anzahl von Komponenten: (1, 2) :: (Int, Int)und (l, 2, 3) :: (Int, Int, Int) sind unterschiedlichen Typs. Die Komponenten können unterschiedlichen Typs sein: (5, "Hallo") ist völlig korrekt. Im Gegensatz dazu haben Listen die folgenden Eigenschaften: Variable Größe, d. h. die Anzahl von Komponenten kann variieren. Daher sind [1, 2] :: [Int] und [1, 2, 3] :: [Int] Listen desselben Typs. Die Komponenten müssen vom gleichen Typ sein. [5, "Hello"] ist unzulässig! Zeichenfolgen als Listen In Haskell sind Zeichenfolgen, also Werte vom Typ String, eigentlich eine spezielle Form von Listen. Der Typ String ist in Haskell folgendermaßen definiert: type String = [Char] Dies bedeutet insbesondere, dass mit Zeichenfolgen Listenoperationen durchgeführt werden können. "Hello"!! 1 'e' In Haskell gelten "Hello" und ['H', 'e', 'l', 'l', 'o'] als identische Ausdrücke. Dies ist sehr praktisch, weil es, wie wir später sehen werden, viele mächtige Listenbearbeitungsoperationen gibt und diese zur Bearbeitung von Zeichenfolgen sofort einsetzbar sind. 3.6 Layout Im Gegensatz zu vielen anderen Programmiersprachen berücksichtigt der Haskell-Interpreter oder -Compiler die Formatierung des Quelltexts. Mit anderen Worten, die Verwendung von Einrückungen und Zeilenumbrüchen ist mit einigen Einschränkungen verbunden. Auf diese Weise kann sich die Sprache einiger Konstruktionen entledigen, die in anderen Sprachen eingeführt wurden, um Doppeldeutigkeiten der Eingabe auszuräumen.

12 3.6 Layout 35 Vergleichen Sie mit foo x = a + b where a = 1 + x b = 2 foo x = a + b where a = 1 + x b = 2 Beides sind zulässige Programme. Im ersten Programm ist b lokal innerhalb von foo definiert, während im zweiten Programm die Verwendung von b nicht auf foo beschränkt ist. Als Beispiel für ein korrektes Layout wird hier die Funktion distance angeführt, die wir weiter oben besprochen haben: distance :: ColourPoint -> ColourPoint -> Float distance (x1, y1, colour1) (x2, y2, colour2) = sqrt (fromint (dx * dx + dy * dy)) where dx = x2 x1 dy = y2 - y1 Es gibt drei Layoutregeln, die Sie befolgen müssen, um syntaktisch korrekte Programme zu erhalten: 1. Der gesamte zu einer Funktionsdefinition gehörige Programmcode muss sich weiter rechts als das erste Zeichen der betreffenden Definition befinden (also rechts vom ersten Zeichen des Funktionsnamens stehen). Im Fall der Funktion distance muss sich der gesamte Quelltext rechts von der Spalte befinden, die den Buchstaben d des Funktionsnamens distance enthält. 2. Analog hierzu muss sich der gesamte Quelltext einer lokalen Definition in einer where-klausel rechts vom ersten Zeichen des Namens der definierten Variablen befinden. 3. Alle Definitionen innerhalb einer where-klausel müssen bündig untereinander ausgerichtet werden, beispielsweise beginnen die Definitionen von dx und dy im obigen Beispiel in derselben Spalte.

13 36 Kapitel 3 Grundlegende Kontrollstrukturen und Typen 3.7 Übungen 1. Schreiben Sie eine Funktion sort2 :: Int -> Int -> (Int, Int), die zwei Werte vom Typ Int als Argumente akzeptiert und diese als sortiertes Paar zurückgibt, so dass sort2 5 3 gleich (3, 5) ist. Wie definieren Sie diese Funktion mit einem Bedingungsausdruck, wie lösen Sie die Funktion unter Verwendung von Funktionen mit Seitenbedingungen? 2. Betrachten Sie die Funktion almostequal :: (Int, Int) -> (Int, Int) -> Bool, welche die Werte von zwei Wertepaaren des Typs Int miteinander vergleicht. Sie liefert das Ergebnis True, wenn beide Paare dieselben Werte enthalten, wobei deren Reihenfolge nicht von Belang ist. Beispielsweise gilt, almostequal (3,4) (4,3) ist True, aber almostequal (3,4) (3,5) ist False. Welche der folgenden Definitionen geben den korrekten Wert zurück? Welche Definition halten Sie für guten Programmierstil? Warum? Fügen Sie den korrekten Definitionen Kommentare hinzu, damit diese verständlicher und leichter lesbar werden. ((&&) :: Bool -> Bool -> Bool entspricht dem logischen 'Und', ( ) :: Bool -> Bool -> Bool entspricht dem logischen 'Oder', und (==) prüft, ob zwei Werte gleich sind.) almostequal (xl, yl) (x2, y2) (xl == x2) && (yl == y2) = True (xl == y2) && (yl == x2) = True otherwise = False almostequal (xl, yl) (x2, y2) (xl == x2) = (yl == y2) (xl == y2) = (yl == x2) otherwise = False almostequal pairl pair2 = (pairl == pair2) (swap pairl == pair2) where swap (x,y) = (y,x) almostequal pairl pair2 = (pairl == pair2) (swap pairl == swap pair2) where swap (x,y) = (y,x) almostequal (xl, yl) (x2, y2) = if (xl == x2) then then if (yl == y2) then True else False else if (xl == y2) then if (x2 == yl) then True else False else False