Beispiele: (Funktionen auf Listen) (3) Bemerkungen: Die Datenstrukturen der Paare (2) Die Datenstrukturen der Paare

Transkript

1 Beispiele: (Funktionen auf Listen) (3) Bemerkungen: 5. Zusammenhängen der Elemente einer Liste von Listen: concat :: [[a]] -> [a] concat xl = if null xl then [] else append (head xl) ( concat (tail xl)) 6. Wende eine Liste von Funktionen vom Typ Int -> Int nacheinander auf eine ganze Zahl an: seqappl :: [( Int -> Int)] -> Int -> Int seqappl xl i = if null xl then i else seqappl (tail xl) (( head xl) i) Rekursive Funktionsdeklaration sind bei Listen angemessen, weil Listen rekursive Datenstrukturen sind. Mit Mustern lassen sich die obigen Deklaration noch eleganter fassen (s. unten). Arnd Poetzsch-Heffter TU Kaiserslautern 241 Arnd Poetzsch-Heffter TU Kaiserslautern 242 Die Datenstrukturen der Paare Die Datenstrukturen der Paare (2) Wir betrachten zunächst Paare und verallgemeinern dann auf n-tupel: Paare oder 2-Tupel sind die Elemente des kartesischen Produktes zweier ggf. verschiedener Mengen oder Typen. Der Typ der Paare ist also ein Produkttyp. 2 Als Typkonstruktor wird (a,b) in Mixfix-Schreibweise benutzt. Haskell stellt standardmäßig eine Datenstruktur für Paare bereit, die bzgl. der Elementtypen parametrisiert ist. Typ: Funktionen: (a,b), a, b sind Typparameter (==), (/=) :: (a, b) (a, b) Bool wenn (==) auf a und b definiert (_,_) :: a b (a, b) fst :: (a, b) a snd :: (a, b) b Konstanten: keine Dem Typ (a,b) ist die Menge der geordneten Paare mit Elementen vom Typ a und b zugeordnet. Arnd Poetzsch-Heffter TU Kaiserslautern 243 Arnd Poetzsch-Heffter TU Kaiserslautern 244

2 Beispiel: (Funktionen auf Paaren) Die Datenstruktur der n-tupel Haskell unterstützt n-tupel für alle n 3: Transformiere eine Liste von Paaren in ein Paar von Listen: unzip :: [(a, b)] -> ([a], [b]) unzip xl = if null xl then ([], []) else ( (fst (head xl)):(fst (unzip (tail xl))), (snd (head xl)):(snd (unzip (tail xl))) ) it = unzip [(1, 2), (3, 4), (9, 10)] (auch das geht erheblich schöner mit Mustern) Typ: Funktionen: (a,b,...), a, b,... sind Typparameter (==), (/=) :: (a, b,...) (a, b,...) Bool wenn (==) auf a, b,... definiert (_,_,...) :: a b... (a, b,...) Konstanten: keine Seien n 3 und a 1,..., a n Typen mit Wertemenge w(a 1 ),..., w(a n ); dann ist dem Tupeltyp (a 1,..., a n ) das kartesische Produkt w(a 1 ) w(a n ) als Wertemengen zugorndet; also eine Menge geordneter n-tupel, wobei das i-te Element vom Typ a i ist. Arnd Poetzsch-Heffter TU Kaiserslautern 245 Arnd Poetzsch-Heffter TU Kaiserslautern 246 Bemerkungen: Die Datenstruktur der Einheit Haskell unterstützt eine Datenstruktur mit einem definierten Wert: Es gibt keine Funkionen, um Elemente aus einem Tupel zu selektieren. Dafür benötigt man Muster (siehe unten). Paare sind wie 2-Tupel, auf ihnen sind aber die Selektorfunktionen fst und snd definiert. Es gibt keine 1-Tupel: Klammern um Ausdrücke dienen nur der Strukturierung und haben darüber hinaus keine Bedeutung; d.h. wenn e ein Ausdruck ist, ist ( e ) gleichbedeutend mit e. Typ: () Funktionen: (==), (/=) :: () () Bool Konstanten: () :: () Dem Typbezeichner () ist eine einelementige Wertemenge zugeordnet. Der Wert wird als Einheit (engl. unity) bezeichnet. Bemerkung: Die Einheit wird oft als Ergebnis verwendet, wenn es keine relevanten Ergebniswerte gibt. Arnd Poetzsch-Heffter TU Kaiserslautern 247 Arnd Poetzsch-Heffter TU Kaiserslautern 248

3 Beispiel: (Geschachtelte Tupel) Beispiel: (Funktionen auf n-tupeln) Mit der Tupelbildung lassen sich baumstrukturierte Werte, sogenannte Tupelterme, aufbauen. So entspricht der Tupelterm: ( (8,True), (("Tupel", "sind", "toll"), "aha")) dem Baum: 1. Flache ein Paar von Paaren in ein 4-Tupel aus: ausflachen :: ((a, b),(c, d)) -> (a, b, c, d) -- nimmt ein Paar von Paaren und liefert 4-Tupel ausflachen pp = ( fst ( fst pp), snd (fst pp), fst (snd pp), snd (snd pp) ) it = ausflachen ( (True,7), ( x,5.6) ) 8 True "aha" "Tupel" "sind" "toll" Alternative Deklaration mit Mustern: ausflachen ((a, b),(c, d)) = (a, b, c, d) 2. Funktion zur Paarbildung: paarung :: a -> b -> (a,b) paarung lk rk = (lk, rk) Arnd Poetzsch-Heffter TU Kaiserslautern 249 Arnd Poetzsch-Heffter TU Kaiserslautern 250 Funktionstypen: Beispiel: Eine zweistellige Funktion f mit Argumenten vom Typ a und Typ b und Ergebnistyp c kann in Haskell auf zwei Arten typisiert werden: 1. Gecurryte Form: f :: a -> b -> c Nach den Präzedenzregeln für -> ist das a -> (b ->c), also eine Funktion, die ein Wert vom Typ a nimmt und eine Funktion vom Typ b -> c liefert. Ist x::a und y::b, dann sind (f x) y oder gleichbedeutend f x y korrekte Anwendungen. 2. Tupel-Form: f :: (a,b) -> c In diesem Fall ist für x::a und y::b, f (x,y) eine korrekte Anwendungen. Die Additionsoperation (+) auf Typ Int hat in Haskell den Typ (+) :: Int -> Int In der Mathematik typisiert man die Additionsoperation plus üblichweise mit: plus :: (Int,Int) -> Int Diese Variante kann man in Haskell wie folgt definieren: plus ip = ( fst ip) + ( snd ip) Oder eleganter mit Mustern: plus (m,n) = m + n Arnd Poetzsch-Heffter TU Kaiserslautern 251 Arnd Poetzsch-Heffter TU Kaiserslautern 252

4 Muster in Deklarationen und Ausdrücken Begriffsklärung: (Muster in Haskell) Muster sind ein Sprachkonstrukt um strukturierte Werte einfacher handhaben zu können (siehe Funktion ausflachen). Ein Wert heißt hier strukturiert, wenn er mittels Konstruktoren aus anderen Werten zusammengebaut wurde. Konstruktoren sind spezielle Haskell-Funktionen. Bisher behandelte Konstruktoren: der Listkonstruktor (:) (daher der Name cons ) die Tupelbildung durch (_,...,_) In werden wir benutzerdefinierte Konstruktoren kennen lernen. Muster (engl. Pattern) in Haskell sind Ausdrücke gebildet über Bezeichnern, Konstanten und Konstruktoren. Alle Bezeichner in einem Muster müssen verschieden sein. Ein Muster M mit Bezeichnern b 1,..., b k passt auf einen strukturierten Wert w (engl.: a pattern matches a value w), wenn es eine Substitution der Bezeichner b j in M durch Werte v j gibt, in Zeichen M[v 1 /b 1,..., v k /b k ], so dass M[v 1 /b 1,..., v k /b k ] = w Arnd Poetzsch-Heffter TU Kaiserslautern 253 Arnd Poetzsch-Heffter TU Kaiserslautern 254 Beispiel: (ML-Muster, Passen) Beispiel: (ML-Muster, Passen) (2) 1. (x,y) passt auf (4,5) mit Substitution x=4, y=5. 2. (ersteselem,zweiteselem) passt auf (-47,(True,"dada")) mit ersteselem =-47, zweiteselem =(True,"dada"). 5. first:rest passt auf ["computo","ergo","sum] mit first ="computo" und rest =["ergo", "sum"]. 6. ((8,x), (y,"aha")) passt auf ((8,True), (("Tupel","sind","toll"), "aha")) mit x = True und y = ("Tupel","sind","toll"). 3. x:xs passt auf 7:8:9:[] mit x = 7 und xs = 8:9:[], d.h. xs = [8,9]. 4. x1:x2:xs passt auf 7:8:9:[] mit x1 = 7, x2 = 8, xs = [9]. 8 True y "aha" Arnd Poetzsch-Heffter TU Kaiserslautern 255 Arnd Poetzsch-Heffter TU Kaiserslautern 256

5 Wertvereinbarungen mit Mustern Funktionsvereinbarung mit Mustern Muster können in Haskell-Wertvereinbarungen verwendet werden: <Muster > = <Ausdruck > ; Wenn das Muster auf den Wert des Ausdrucks passt und σ die zugehörige Substitution ist, werden die Bezeichner im Muster gemäß σ an die zugehörige Werte gebunden. Wenn das Muster auf den Wert des Ausdrucks nich passt, wird eine Ausnahme erzeugt, sobald auf einen der deklarierten Bezeichner zugegriffen wird. Beispiel: (x, y) = (4, 5); Muster können in Haskell-Funktionsdeklarationen verwendet werden (vgl. Folie 222): <Funktionsbez > <Parametermuster >... = <Ausdruck >... <Funktionsbez > <Parametermuster >... = <Ausdruck > Bei der Funktionsanwendung wird der Reihe nach geprüft, auf welches Parametermuster der aktuelle Parameter passt (vgl. Folie 229). Die Gleichung zum ersten passenden Fall wird verwendet. Arnd Poetzsch-Heffter TU Kaiserslautern 257 Arnd Poetzsch-Heffter TU Kaiserslautern 258 Beispiele: (Funktionsdeklaration mit Mustern) Beispiele: (Funktionsdeklaration mit Mustern) (2) 1. Deklaration von foldplus ohne Muster: foldplus :: [Int] -> Int foldplus xl = if null xl then 0 else (head xl) + foldplus (tail xl) Deklaration von foldplus mit Muster: foldplus :: [Int] -> Int foldplus [] = 0 foldplus (x: xl) = x + foldplus xl 2. Deklaration von ist_sortiert::[int] ->Bool mit drei Mustern: ist_sortiert [] = True ist_sortiert (x:[]) = True ist_sortiert ( x1: x2: xs) = if x1 <= x2 then ist_sortiert ( x2: xs ) else False Deklaration mit drei Mustern und Wächtern: ist_sortiert [] = True ist_sortiert (x:[]) = True ist_sortiert ( x1: x2: xs) x1 <= x2 = ist_sortiert ( x2: xs) otherwise = False Arnd Poetzsch-Heffter TU Kaiserslautern 259 Arnd Poetzsch-Heffter TU Kaiserslautern 260

6 Beispiele: (Funktionsdeklaration mit Mustern) (3) Beispiele: (Funktionsdeklaration mit Mustern) (4) Deklaration von ist_sortiert::[int]->bool mit zwei Mustern und Wächtern: ist_sortiert ( x1: x2: xs) x1 <= x2 = ist_sortiert ( x2: xs) otherwise = False ist_sortiert x = True 3. Deklaration von append ::[a]->[a]->[a]: append ([], l2) = l2 append (( x: xs), l2) = x : ( append (xs, l2)) 4. Verwendung geschachtelter Muster: unzip :: [(a, b)] -> ([a],[b]) unzip [] = ([], []) unzip ((x,y):ps) = ( (x : (fst (unzip ps))), (y : (snd (unzip ps))) ) Arnd Poetzsch-Heffter TU Kaiserslautern 261 Arnd Poetzsch-Heffter TU Kaiserslautern 262 let-ausdruck Beispiele: (let-ausdruck) Der Mustermechanismus kann auch innerhalb von Ausdrücken eingesetzt werden. Syntax des let-ausdrucks: let <Liste von Deklarationen > in <Ausdruck > Die aus den Deklarationen resultierenden Bindungen sind nur im let-ausdruck gültig. D.h. sie sind sichtbar im let-ausdruck an den Stellen, an denen sie nicht verdeckt sind. a = let a = 2*3 in a*a b = let a = 2*3 in let (b,c) = (a,a+1) in a*b*c unzip :: [(a, b)] -> ([a], [b]) unzip [] = ([], []) unzip ((x,y): ps) = let (xs, ys) = unzip ps in ((x:xs), (y:ys)) Arnd Poetzsch-Heffter TU Kaiserslautern 263 Arnd Poetzsch-Heffter TU Kaiserslautern 264

7 case-ausdruck Beispiele: (case-ausdruck) Syntax des case-ausdrucks: case <Ausdruck0 > of <Muster1 > -> <Ausdruck1 >... <MusterN > -> <AusdruckN > Prüfe der Reihe nach, ob der resultierende Wert von <Ausdruck0> auf eines der Muster passt. Passt er auf ein Muster, nehme die entsprechenden Bindungen vor und werte den zugehörigen Ausdruck aus (die Bindungen sind nur in dem zugehörigen Ausdruck gültig). ist_sortiert xl = case xl of [] -> True (x:[]) -> True ( x1: x2: xs) -> if x1 <= x2 then ist_sortiert ( x2: xs) else False Arnd Poetzsch-Heffter TU Kaiserslautern 265 Arnd Poetzsch-Heffter TU Kaiserslautern 266 Bemerkungen: Unterabschnitt Das Verbot von gleichen Bezeichnern in Mustern hat im Wesentlichen den Grund, dass nicht für alle Werte/Typen die Gleichheitsoperation definiert ist. mal2 = \x -> 2* x twotimes = \x -> x+x (a,a) = (mal2, twotimes) Benutzerdefinierte Datentypen Wenn keines der angegebenen Muster passt, wird eine Ausnahme erzeugt (abrupte Terminierung). Arnd Poetzsch-Heffter TU Kaiserslautern 267 Arnd Poetzsch-Heffter TU Kaiserslautern 268

8 Benutzerdefinierte Datentypen Vereinbarung von Typbezeichnern Fast alle modernen Spezifikations- und Programmiersprachen gestatten es dem Benutzer, neue Typen zu definieren. Übersicht: Vereinbarung von Typbezeichnern Deklaration neuer Typen Summentypen Rekursive Datentypen Haskell erlaubt es, Bezeichner für Typen zu deklarieren (vgl. F. 209): type IntPaar = (Int, Int) ; type CharList = [Char] ; type Telefonbuch = [((String,String,String,Int),[String])] ; type IntegerNachInteger = Integer -> Integer ; fakultaet :: IntegerNachInteger ; -- Argument muss >= 0 sein fakultaet = fac ; Dabei wird kein neuer Typ definiert, sondern nur ein neuer Bezeichner an einen bekannten Typ gebunden. Arnd Poetzsch-Heffter TU Kaiserslautern 269 Arnd Poetzsch-Heffter TU Kaiserslautern 270 Bemerkungen: (Typvereinbarungen) Deklaration neuer Typen Typvereinbarungen können zur Abkürzung oder zur Verdeutlichung benutzt werden (siehe Typ Telefonbuch). Zwei unterschiedliche Bezeichner können den gleichen Typ bezeichnen; z.b.: type IntTriple = (Int,Int, Int) type Date = (Int,Int, Int) kalenderwoche :: Date -> Int -- Parameter muss existierenden Kalendertag sein kalenderwoche (tag, monat, jahr) =... kalenderwoche (11,12,2003) Neue Typen werden in Haskell mit der datatype-deklaration definiert, die im Folgenden schrittweise erläutert wird. Definition eines neuen Typs und Konstruktors: data <NeuerTyp > = <Konstruktor > <Typ1 >... <TypN > Die obige Datatypdeklaration definiert: einen neuen Typ und bindet ihn an <NeuerTyp> eine Konstruktorfunktion mit Signatur <Konstruktor >:: <Typ1 > ->... -> <TypN > -> <NeuerTyp > Die Konstruktorfunktion ist injektiv. Typ- und Konstruktorbezeichner müssen mit einem Großbuchstaben beginnen. Arnd Poetzsch-Heffter TU Kaiserslautern 271 Arnd Poetzsch-Heffter TU Kaiserslautern 272

9 Beispiel: (Definition von Typ, Konstruktor, Selektoren) Bemerkungen: data Person = Student String String Int Int definiert den neuen Typ Person und den Konstruktor Student :: String -> String -> Int -> Int -> Person Wir definieren dazu folgende Selektorfunktionen: vorname :: Person -> String vorname ( Student v n g m) name :: Person -> String name ( Student v n g m) = v = n Jede Datentypdeklaration definiert einen neuen Typ, d.h. insbesondere: die Werte des neuen Typs sind inkompatibel mit allen anderen Typen; auch Werte strukturgleicher benutzerdefinierter Typen sind inkompatibel. geburtsdatum :: Person -> Int geburtsdatum ( Student v n g m) = g matriknr :: Person -> Int matriknr ( Student v n g m) = m Arnd Poetzsch-Heffter TU Kaiserslautern 273 Arnd Poetzsch-Heffter TU Kaiserslautern 274 Beispiele: (Typkompatibilität) Bemerkung: 1. Der Typ Person ist inkompatibel mit dem Tupeltyp type Person2 = ( String, String,Int, Int) Insbesondere ist vorname ("Niels","Bohr", ,221) nicht typkorrekt. 2. Person ist inkompatibel mit dem strukturgleichen Typ Adresse: data Adresse = Wohnung String String Int Int Insbesondere ist name ( Wohnung " Casimirring" " Lautern" ) nicht typkorrekt. Den Konstruktor kann man sich als eine Markierung der Werte seines Argumentbereichs vorstellen. Dabei werden Werte mit unterschiedlicher Markierung als verschieden betrachtet. Konstruktoren erlauben es in gewisser Weise neue Produkttypen zu definieren. Arnd Poetzsch-Heffter TU Kaiserslautern 275 Arnd Poetzsch-Heffter TU Kaiserslautern 276

10 Summentypen Beispiele: (Summentypen) Ein Summentyp stellt die disjunkte Vereinigung der Elemente anderen Typen zu einem neuen Typ dar. Die meisten modernen Programmiersprachen unterstützen die Deklaration von Summentypen. In Haskell definiert man Summentypen durch Angabe von Alternativen bei der datatype-deklaration: data <NeuerTyp > = <Konstruktor1 > <Typ1_1 >... <Typ1_N1 > <Konstruktor2 > <Typ2_1 >... <Typ2_N2 >... <KonstruktorM > <TypM_1 >... <TypM_NM > 1. Ein anderer Datentyp zur Behandlung von Personen: data Person2 = Student String String Int Int Mitarbeiter String String Int Int Professor String String Int Int String Arnd Poetzsch-Heffter TU Kaiserslautern 277 Arnd Poetzsch-Heffter TU Kaiserslautern 278 Beispiele: (Summentypen) (2) Beispiele: (Summentypen) (3) 2. Eine benutzerdefinierte Datenstruktur für Zahlen: data MyNumber = Intc Int Floatc Float isint (Intc m) = True isint ( Floatc r) = False isfloat (Intc m) = False isfloat ( Floatc r) = True neg :: MyNumber -> MyNumber neg (Intc m) = Intc (-m) neg ( Floatc r) = Floatc (-r) plus :: MyNumber -> MyNumber -> MyNumber plus (Intc m) (Intc n) = Intc (m+n) plus (Intc m) ( Floatc r) = Floatc (( frominteger ( tointeger m))+r) plus ( Floatc r) (Intc m) = Floatc (r+( frominteger ( tointeger m))) plus ( Floatc r) ( Floatc q) = Floatc (r+q) Arnd Poetzsch-Heffter TU Kaiserslautern 279 Arnd Poetzsch-Heffter TU Kaiserslautern 280