Grundlagen der Programmierung 2 (1.C)

Transkript

1 Grundlagen der Programmierung 2 (1.C) Prof. Dr. Manfred Schmidt-Schauÿ Künstliche Intelligenz und Softwaretechnologie 8. Mai 2007

2 Listen und Listenfunktionen Listen modellieren Folgen von gleichartigen, gleichgetypten Objekten. [0,1,2,3,4,5,6,7,8,9] Typ: [Integer]; d.h. Liste von Integer. [] leere Liste, (Nil) [ a, b, c ] Typ: [Char]; abgekürzt als String Druckbild: "abc" [[], [0], [1, 2]] Liste von Listen; Typ [[Integer]], d.h. eine Liste von Listen von Integer-Objekten. [1..] potentiell unendliche Liste [1,2,3,...] Grundlagen der Programmierung 2 (1.C) - 1 -

3 Listen und Listenfunktionen zwei Schreibweisen für Listen: [0, 1, 2] (0 : (1 : (2 : []))) schöne Darstellung interne Darstellung mit Druckbild einer Liste zweistelligem Infix-Listen-Konstruktor : und dem Konstruktor [] Eingebaute, listenerzeugende Funktionen: [n..] erzeugt die Liste der Zahlen ab n. [n..m] erzeugt die Liste von n bis m [1..10] ergibt [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] [n,m..k] erzeugt die Liste von n bis k mit Schritten m n Grundlagen der Programmierung 2 (1.C) - 2 -

4 Darstellung von Listen Listen sind aufgebaut mittels zwei Konstruktoren: [] Konstante für die leere Liste : Zweistelliger Infix-Konstruktor a : b Linkes Argument a: erstes Element der Liste Rechtes Argument b: Restliste Beispiel für Haskells Listenerzeugung: 8:[] Liste [8] mit dem Element 8 9:(8:[]) Liste [9,8] mit zwei Elementen 8,9 10:(9:(8:[])) Liste [10,9,8] mit drei Elementen Grundlagen der Programmierung 2 (1.C) - 3 -

5 Baum-Bild einer Liste 10 : 9 : 8 [] : entspricht [10, 9, 8] Grundlagen der Programmierung 2 (1.C) - 4 -

6 Einfache Listenfunktionen Definitionen head (x:xs) = x --Erstes Element tail (x:xs) = xs --Restliste Auswertungen head [] head [1] tail [] tail [1] Grundlagen der Programmierung 2 (1.C) - 5 -

7 Beispiel lengthr lengthr [] = 0 lengthr (x:xs) = 1 + (lengthr xs) Auswertung bei bereits ausgewerteter Liste lengthr (10:(9:(8:[]))) Zweiter Fall; [10/x,(9:(8:[]))/xs] 1+ (lengthr (9:(8:[]))) Zweiter Fall; [9/x, (8:[])/xs] 1+(1+ (lengthr (8:[]))) Zweiter Fall; [8/x, ([])/xs] 1+(1+ (1+ (lengthr []))) Erster Fall; 1+(1+ (1+ (0))) 3 Addition 3 Grundlagen der Programmierung 2 (1.C) - 6 -

8 Funktionen auf Listen: map map :: (a -> b) -> [a] -> [b] map f [] = [] map f (x:xs) = (f x) : (map f xs) map wendet eine Funktion f auf alle Elemente einer Liste an und konstruiert die Liste der Ergebnisse. [] und (x:xs) links sind Muster(Pattern) Z.B. Muster (x:xs) und Argument (s:t) ergibt die Ersetzung: [s/x, t/xs] Grundlagen der Programmierung 2 (1.C) - 7 -

9 Funktionen auf Listen: Beispiele map f [] = [] map f (x:xs) = (f x) : (map f xs) Auswertung von map quadrat (1:(2:[])): map quadrat (1:(2:[])) [quadrat/f, 1/x, (2:[])/xs] quadrat 1 : map quadrat (2:[]) bei vollst. Auswertung: 1*1 : map quadrat (2:[]) 1 : map quadrat (2:[]) Zweite Gleichung 1 : (quadrat 2 : map quadrat []) wg Interpreter 1 : (2*2 : map quadrat []) 1 : (4 : map quadrat []) Erste Gleichung 1 : (4 : []) = [1,4] Grundlagen der Programmierung 2 (1.C) - 8 -

10 Auswertung: Wieviel ist nötig? istleer [] = True istleer (x:xs) = False zahlenab n = n: zahlenab (n+1) Auswertung (mit nicht ausgewerteter Liste) istleer [1..] istleer (zahlenab 1) istleer (1: zahlenab (1+1)) False verwende zahlenab Zweite Gleichung von istleer Grundlagen der Programmierung 2 (1.C) - 9 -

11 Listenfunktionen und Listenerzeuger *Main> map quadrat [1..10] [1,4,9,16,25,36,49,64,81,100] *Main> map quadrat [1..] [1,4,9,16,25,36,49,64,81,100,121,... Der Listenerzeuger [1..] erzeugt soviel von der Liste [1,2,3,4,5, usw. wie von der Listenfunktion benötigt wird. Grundlagen der Programmierung 2 (1.C)

12 Typen von Listenausdrücken mapquadrat xs = map quadrat xs mapquadrat :: forall a. (Num a) => [a] -> [a] maplength xs = map length xs maplength :: forall a. [[a]] -> [Int] Grundlagen der Programmierung 2 (1.C)

13 Listenfunktion append Die folgende Funktion hängt zwei Listen zusammen: append :: [a] -> [a] -> [a] append [] ys = ys append (x:xs) ys = x : (append xs ys) Haskell-Operator für append: ++ (Infix-Operator) Haskell-Schreibweise: [1,2,3] ++ [4,5,6,7] Grundlagen der Programmierung 2 (1.C)

14 Beispiele Main> [] ++ [3,4,5] [3,4,5] Main> [0,1,2] ++ [] [0,1,2] Main> [0,1,2] ++ [3,4,5] [0,1,2,3,4,5] Main> [ ] ++ [ ] == [ ] True Grundlagen der Programmierung 2 (1.C)

15 Funktionen auf Listen (2) Filtern von Elementen aus einer Liste: filter :: (a -> Bool) -> [a] -> [a] filter f [] = [] filter f (x:xs) = if (f x) then x : filter f xs else filter f xs Beispiele: filter (< 5) [1..10] [1,2,3,4] *Main> filter primzahlq [2..] [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71, 73,79,83,89,97,101,103,107,109,113,127,131,137,139, 149,151,157,163,167,173,179,181,191,193,197,199,211, Grundlagen der Programmierung 2 (1.C)

16 Funktionen auf Listen Die ersten n Elemente der Liste xs: take :: Int -> [a] -> [a] take 0 _ = [] take n [] = [] take n (x:xs) = x : (take (n-1) xs) *Main> take 10 [20..40] [20,21,22,23,24,25,26,27,28,29] *Main> take 10 [20,23..] [20,23,26,29,32,35,38,41,44,47] Grundlagen der Programmierung 2 (1.C)

17 Auswertungsreihenfolge, Definitionseinsetzung Auswertung von f s 1... s n wenn Muster verwendet wurden: Vor Definitionseinsetzung diejenigen Argumente auswerten, die für die Fallunterscheidung benötigt werden. Aber nur soviel wie nötig Zuordnung: Mustervariablen zu Ausdruck analog wie Zuordnung: formale Parameter zu Argumenten. Grundlagen der Programmierung 2 (1.C)

18 Iterative Prozesse mit Listenargumenten Bei Verwendung von Listenargumenten: Die folgenden Begriffe sind unverändert: linear rekursiv, end-rekursiv, Baum-rekursiv geschachtelt Baum-rekursiv (Bei applikativer Reihenfolge der Auswertung) iterativ muss angepasst werden. Grundlagen der Programmierung 2 (1.C)

19 Iterativer Auswertungsprozess zu f Ein iterativer Auswertungsprozess liegt vor, bei rekursiver Funktion f, wenn: (f a 1... a n ) (f a 1... a n) (f a (2) 1... a(2) n ) (f a (3) 1... a(3) n ) (f a (m) 1... a (m) n )... und alle a (j) i sind Basiswerte oder komplett ausgewertete, endliche Listen bei applikativer Reihenfolge der Auswertung Grundlagen der Programmierung 2 (1.C)

20 iterative Version f iter von f f iter ist iterative Version von f Wenn: f und f iter das gleiche berechnen und f iter einen iterativen Prozess erzeugt für alle Basiswerte und alle komplett ausgewerteten endlichen Listen als Eingaben Grundlagen der Programmierung 2 (1.C)

21 Listen: Auswertung Listenargumente nennt man: einfach ausgewertet: wenn Listen-Fallunterscheidung möglich ist, d.h. [] oder : ist Top-Konstruktor des Arguments Grundlagen der Programmierung 2 (1.C)

22 Beispiel: iterative Version von lengthr: length_lin xs = length_linr 0 xs length_linr s [] = s length_linr s (x:xs) = length_linr (s+1) xs nicht-iterative Version: lengthr [] = 0 lengthr (x:xs) = 1 + lengthr xs Grundlagen der Programmierung 2 (1.C)

23 Linearer (Nicht-iterativer) Prozess zu lengthr lengthr (9:(8:(7:(6:...(1:[]))))) 1+(lengthr (8:(7:(6:...(1:[])))) 1+(1+(lengthr (7:(6:...(1:[]))) 1+(1+(1+(lengthr (6:...(1:[]))... (1+(1+(1+(1+(1+(1+(1+(1+(1+0))))))))))... 9 Grundlagen der Programmierung 2 (1.C)

24 Beispiel: iterativer Prozess Beachte: wir benutzen hier die applikative Reihenfolge der Auswertung length_lin (9:(8:(7:(6:...(1:[]))))) length_linr 0 (9:(8:(7:(6:...(1:[]))))) length_linr 1 (8:(7:(6:...(1:[])))) length_linr 2 (7:(6:...(1:[]))) length_linr 3 (6:...(1:[]))... length_linr 9 [] Grundlagen der Programmierung 2 (1.C)

25 Allgemeine Funktionen auf Listen Allgemeine Funktionen (Methoden): foldl und foldr Links-Faltung und Rechts-Faltung Die 3 Argumente sind: eine zweistellige Operation, ein Anfangselement (Einheitselement) und die Liste. foldl e [a 1,..., a n ] entspricht ((... ((e a 1 ) a 2 )... ) a n ). foldr e [a 1,..., a n ] entspricht a 1 (a 2 (... (a n e))) Grundlagen der Programmierung 2 (1.C)

26 Definitionen der fold-funktionen foldl (Linksfaltung) foldr (Rechtsfaltung) foldl foldl f z [] foldl f z (x:xs) :: (a -> b -> a) -> a -> [b] -> a = z = foldl f (f z x) xs foldr foldr f z [] foldr f z (x:xs) :: (a -> b -> b) -> b -> [a] -> b = z = f x (foldr f z xs) Grundlagen der Programmierung 2 (1.C)

27 Fold-Verwendungen Summe bzw. Produkt einer Liste von Zahlen: sum xs = foldl (+) 0 xs produkt xs = foldl (*) 1 xs concat xs = foldr (++) [] xs foldl (+) 0 [1,2,3,4] ((((0+1)+2)+3)+4) foldr (++) [] [[0],[2,3],[5]] [0] ++ ([2,3] ++ ([5] ++ [])) Je nach Operator is foldl, oder foldr besser geeignet. Grundlagen der Programmierung 2 (1.C)

28 Lokale Funktionsdefinitionen, anonyme Funktionen, Lambda-Ausdrücke Lambda-Ausdruck \x 1... x n -> Ausdruck Die Notation \x -> ist Ersatz für die Church-Notation: λx. Beispiel quadrat = \x -> x*x Lokale Funktionsdefinition: Anonyme Funktion Lambda-Ausdruck an der Stelle von f Lambda-Ausdruck hat keinen Namen Äquivalent sind: \x1 -> (\x2 ->... (\xn -> t)...) und \x1 x2... xn -> t. Grundlagen der Programmierung 2 (1.C)

29 let und lokale Bindungen let {x 1 = s 1 ;... ; x n = s n } in t {x 1 = s 1 ;... ; x n = s n } ist eine lokale Umgebung die Variablen x i können in t vorkommen mit der Bedeutung: Wert von s i t der eigentliche Ausdruck In Haskell: rekursives let. D.h. x i kann in jedem s j vorkommen Beachte im ghci-interpreter: Spezielle Verwendung des let Grundlagen der Programmierung 2 (1.C)

30 Erweiterungen des let Funktionen sind definierbar direkt in einem rekursiven let: let {f x 1... x n = s;...} in t ist das gleiche wie: let {f = \x 1... x n -> s;...} in t Grundlagen der Programmierung 2 (1.C)

31 Reduktionen von let-ausdrücken Reduktion eines nicht-rekursiven let: let {x 1 = s 1 ;... ; x n = s n } in t t[s 1 /x 1,..., s n /x n ] mit Sharing-Markierungen Wie man ein rekursives let weiter-reduzieren kann: mit σ = [s 1 /x 1,..., s n /x n ] let {x 1 = s 1 ;... ; x n = s n } in t let {x 1 = s 1 σ;... ; x n = s n σ} in tσ Grundlagen der Programmierung 2 (1.C)

32 Freie und Gebundene Variablen, Gültigkeitsbereiche Um Definitionen von lokalen Namen korrekt zu handhaben braucht man neue Begriffe: Gültigkeitsbereich einer Variablen x freie Variablen eines Ausdrucks gebundene Variablen eines Ausdrucks Text-Fragment(e) des Programms in dem dieses x gemeint ist. Variablen, deren Bedeutung außerhalb des Ausdrucks festgelegt wird. Variablen, deren Bedeutung innerhalb des Ausdrucks festgelegt wird. Problem: Variablen können mit gleichem Namen, aber verschiedener Bedeutung in einem Ausdruck vorkommen: Lösung: Exakte Festlegung der Gültigkeitsbereiche für jedes syntaktische Konstrukt Umbenennen von gebundenen Variablennamen, falls nötig Grundlagen der Programmierung 2 (1.C)

33 Beispiel \x-> x*x x*x Gültigkeitsbereich von x: der Ausdruck x*x die Variable x ist gebunden von \x in diesem Ausdruck ist x frei Grundlagen der Programmierung 2 (1.C)

34 Definition von FV FV: ergibt Menge von Variablen-Namen. F V (x) := {x}, wenn x ein Variablenname ist F V ((s t)) := F V (s) F V (t) F V (if t 1 then t 2 else t 3 ) := F V (t 1 ) F V (t 2 ) F V (t 3 ) F V (\x 1... x n -> t) := F V (t) \ {x 1,..., x n } F V (let x 1 = s 1,..., x n = s n in t) := (F V (t) F V (s 1 )... F V (s n )) \ {x 1,..., x n } F V (let f x 1... x n = s in t) := F V (let f = \x 1... x n -> s in t) Beachte: FV ist eine Funktion auf dem Syntaxbaum keine Haskell-Funktion Grundlagen der Programmierung 2 (1.C)

35 Beispiel: freie Variablen F V (\x -> (f x y)) = F V (f x y ) \ {x} =... = {x, f, y} \ {x} = {f, y} Grundlagen der Programmierung 2 (1.C)

36 Gebundene Variablen GV (t) Entsprechend der F V -Definition: GV (x) := GV ((s t)) := GV (s) GV (t) GV (if t 1 then t 2 else t 3 ) := GV (t 1 ) GV (t 2 ) GV (t 3 ) GV (\x 1... x n -> t) := GV (t) {x 1,..., x n } GV (let x 1 = s 1,..., x n = s n in t) := (GV (t) GV (s 1 )... GV (s n ) {x 1,..., x n }}) GV (let f x 1... x n = s in t) := GV (let f = \x 1... x n -> s in t) = {f, x 1,..., x n } GV (s) GV (t) Grundlagen der Programmierung 2 (1.C)

37 Beispiel : Berechnung von gebundenen Variablen GV(\x -> (f x y)) = GV (f x y) {x} =... = {x} = {x} Grundlagen der Programmierung 2 (1.C)

38 Lexikalischer Gültigkeitsbereich einer Variablen let x = s in t die Vorkommen der freien Variablen x in s, t werden gebunden. s, t ist der Gültigkeitsbereich der Variablen x \x 1... x n -> t die freien Variablen x 1,..., x n in t werden gebunden. t ist der Gültigkeitsbereich der Variablen x 1,..., x n. Grundlagen der Programmierung 2 (1.C)

39 Beispiel Ausdruck t = \x -> (x (\x -> x*x)) x ist in t gebunden, aber in zwei Bindungsbereichen: \x -> (x (\x -> x*x)) In (x (\x -> x*x)) kommt x frei und gebunden vor. Umbenennen des gebundenen x in y ergibt: (x (\y -> y*y)) Grundlagen der Programmierung 2 (1.C)

40 Beispiele Zwei Bindungsbereiche für x in einem let-ausdruck: let x = 10 in (let x = 100 in (x+x)) + x Umbenennung ergibt: let x1 = 10 in (let x2 = 100 in (x2+x2)) + x1 Dieser Term wertet zu 210 aus. Grundlagen der Programmierung 2 (1.C)

41 Beispiele Der Ausdruck let x = (x*x) in (x+x) führt zu Nichtterminierung. Grundlagen der Programmierung 2 (1.C)

42 Beispiel: Reihenfolgenunabhängigkeit der Bindungen let y = 20*z x = 10+y z = 15 in x Wertet aus zu : 310. Grundlagen der Programmierung 2 (1.C)

43 Beispiel geschachtelte Bindungsbereiche let {x = 1;y = 2} in (let {y = 2; z = 4} in (let z = 5 in (x+y+z))) x = 1; y = 2 y = 2; z = 4 z = 5 (x+y+z) Grundlagen der Programmierung 2 (1.C)

44 Programm als let Ein Programm mit den Definitionen f i := e i i = 1,..., n und dem auszuwertenden Ausdruck main kann als großes let betrachtet werden: let {f 1 := e 1 ;... ; f n := e n } in main Grundlagen der Programmierung 2 (1.C)

45 Optimierung mittels let Vermeidung redundanter Auswertungen mit let f(x, y) := x(1 + xy) 2 + y(1 y) + (1 + xy)(1 y) optimierbar durch Vermeidung von Doppelauswertungen: Der zugehörige Ausdruck ist: let a b in = 1 + x*y = 1 - y x*a*a + y*b + a*b Grundlagen der Programmierung 2 (1.C)

46 Allgemeine Methoden: Funktionen als Argumente Funktionen höherer Ordnung Beispiele für (arithmetische) Aufgabenstellungen: Nullstellenbestimmung, Integrieren, Differenzieren, Ermitteln von Maxima, Minima von Funktionen... Grundlagen der Programmierung 2 (1.C)

47 Nullstellenbestimmung einer stetigen Funktion mit Intervallhalbierung Sei f stetig und f(a) < 0 < f(b), m = (a + b)/2 f a m = (a+b)/2 b wenn f(m) > 0, dann Nullstelle in [a, m]. wenn f(m) < 0, dann Nullstelle in [m, b]. Grundlagen der Programmierung 2 (1.C)

48 Nullstellenbestimmung: Programm (1) Parameter: Name der arithmetischen (Haskell-) Funktion Intervall-Anfang Intervall-Ende Genauigkeit der Nullstelle (absolut). suche_nullstelle:: (Double->Double) -> Double -> Double -> Double -> Double suche_nullstelle f a b genau =... (siehe Programmfile) Grundlagen der Programmierung 2 (1.C)

49 Nullstellenbestimmung: Programm (3) *Main> suche_nullstelle cos *Main> /pi 0.5 *Main> pi/ *Main> Grundlagen der Programmierung 2 (1.C)

50 Intervallhalbierungsmethode: Komplexität maximale Anzahl der Schritte: log 2 (L/G), wobei L Länge des Intervalls G Genauigkeit Zeitbedarf: Platzbedarf: O(log(L/G)) O(1) Grundlagen der Programmierung 2 (1.C)

51 Funktionen als Ergebnis Beispiel: Komposition von Funktionen: komp::(a -> b) -> (c -> a) -> c -> b komp f g x = f (g x) In Haskell ist komp vordefiniert und wird als. geschrieben: *Main> suche_nullstelle (sin. quadrat) (sin. quadrat) entspricht sin(x 2 ) und quadrat. sin entspricht (sin(x)) 2. Grundlagen der Programmierung 2 (1.C)

52 Typ der Komposition Erklärung zum Typ von komp, wobei {a,b,c} Typvariablen sind Ausdruck: f 1 komp f 2 bzw. f 1. f 2 (a->b) -> (c->a) -> c->b Typ von (.) (a->b) Typ von f 1 (c->a) Typ von f 2 c Typ des Arguments x der Komposition f 1. f 2 b Typ des Resultats der Komposition f 1 (f 2 x) f 1. f 2 :: c -> b. Grundlagen der Programmierung 2 (1.C)

53 Datentypen in Haskell Wir kennen schon: Basisdatentypen Ganze Zahlen (Int) Unbeschränkte ganze Zahlen (Integer). Rationale Zahlen. Komplexe Zahlen (im Haskell-Module Complex). Gleitkommazahlen (Gleitpunktzahlen) (Float).(Double). z.b e-40 Zeichen, Character. i.a. ASCII-Zeichen zu 1 Byte bzw. Unicode Listen, konstruiert mit : und []. Grundlagen der Programmierung 2 (1.C)

54 Zusammengesetzte Daten-Objekte Paar: (x, y) Beispiele (1, 2) (1, "hallo") (1,(2,"hallo")) (Paar von Zahl und Paar...) Grundlagen der Programmierung 2 (1.C)

55 Anwendungs-Beispiel: Rationale Zahlen Repräsentation als Paar: (Zähler, Nenner) Beachte: in Haskell vordefiniert x in Haskell als x%y gedruckt. y Beispiele: Prelude> (3%4)*(4%5) 3 % 5 Prelude> 1%2+2%3 7 % 6 Datenkonversionen: z.b. torational, truncate. Grundlagen der Programmierung 2 (1.C)

56 n-tupel von Objekten Als Verallgemeinerung von Paaren (t 1,..., t n ) ist n-tupel von t 1,..., t n Beispiele (1,2,3,True) (1,(2,True),3) ("hallo",false) (fakultaet 100,\x-> x) Grundlagen der Programmierung 2 (1.C)

57 Zusammengesetzte Objekte: Datentypen Für Datentypen benötigt man: Datenkonstruktor(en) Datenselektor(en) Beispiel Paarkonstruktor s, t (s, t) Paarselektoren fst, snd Eigenschaften: fst(s, t) = s snd(s, t) = t. und Grundlagen der Programmierung 2 (1.C)

58 Beispiel n-tupel n-tupelkonstruktor t 1,..., t n (t 1,..., t n ) Tupelselektoren n Selektoren: pro Stelle ein Selektor n-tupel haben einen impliziten Konstruktor: (.,...,.) }{{} n Grundlagen der Programmierung 2 (1.C)

59 Definition der Selektoren Muster (pattern) statt Selektoren. Muster sind syntaktisch dort erlaubt, wo formale Parameter (Variablen) neu eingeführt werden: in Funktionsdefinitionen, in Lambda-Ausdrücken und in let-ausdrücken. Beispiel-Definitionen von Selektoren mittels Muster fst (x,y) = x snd (x,y) = y selektiere_erstes_von_3 (x1,x2,x3) = x1 selektiere_zweites_von_3 (x1,x2,x3) = x2 selektiere_drittes_von_3 (x1,x2,x3) = x3 Grundlagen der Programmierung 2 (1.C)

60 Beispiel: Typen von Selektoren, Konstruktoren, Tupeln (1, 1) :: (Integer, Integer) (1, (2, True)) :: (Integer, (Integer, Bool)) (.,...,.) :: α 1 α 2... α n (α 1, α 2,..., α n ) }{{} n selektiere_drittes_von_3 :: (α 1, α 2, α 3 ) α 3 Grundlagen der Programmierung 2 (1.C)

61 Benutzerdefinierte Konstruktoren Definierbar in Haskell mittels data-anweisung Beispiel data Punkt = Punktkonstruktor Double Double data Strecke = Streckenkonstruktor Punkt Punkt data Viertupel a b c d = Viertupelkons a b c d Grundlagen der Programmierung 2 (1.C)

62 Muster (pattern) Nutzen der Muster: Gleichzeitiges und tiefes Selektieren Ersatz für Selektoren Syntax der Muster: Muster ::= Variable ( Muster ) Konstruktor (n) Muster... Muster }{{} n ( Muster,..., Muster ) Kontextbedingung: in einem Muster keine Variable doppelt Grundlagen der Programmierung 2 (1.C)

63 Auswertung unter Benutzung von Mustern Mustervergleich: Anpassen des Objekts an das Muster gleichzeitige Selektion mittels impliziter let-bindungen I.a. vorher Auswertung des Objekts erforderlich Beispiele (x,y,(u,v)) anpassen an: (1,2,(3,4)) ergibt: let {x = 1;y = 2;u = 3;v = 4} in... (x,y,(u,v)) anpassen an: (1,2,True) ergibt: Fehler. Kann nicht vorkommen wegen Typcheck. (x,y,u) anpassen an: (1,2,(4,5)) ergibt: let {x = 1; y = 2;u = (4,5)} in... Grundlagen der Programmierung 2 (1.C)

64 Auswertung unter Benutzung von Mustern (2) Beispiele (x,y) anpassen an: (1,fakt 100) ergibt: {let {x = 1; y = fakt 100} in... (x,y) anpassen an: (fst (1,2), snd (fakt 100,fakt 200)) ergibt : let {x = fst (1,2); y = snd (fakt 100, fakt 200)} in... Grundlagen der Programmierung 2 (1.C)

65 Benutzerdefinierte Typnamen mit Parametern Beispiel Punkt, Strecke, Polygonzug data Punkt a = Punkt a a data Strecke a = Strecke (Punkt a) (Punkt a) data Vektor a = Vektor a a data Polygon a = Polygon [Punkt a] Typ und Konstruktor können gleiche Namen haben. Der Parameter a kann jeder Typ sein: z.b.: Float, Int, aber auch [[(Int, Char)]] Grundlagen der Programmierung 2 (1.C)

66 Funktionen auf Punkt, Strecke, Polygonzug addierevektoren::num a => Vektor a -> Vektor a -> Vektor a addierevektoren (Vektor a1 a2) (Vektor b1 b2) = Vektor (a1 + b1) (a2 + b2) streckenlaenge (Strecke (Punkt a1 a2) (Punkt b1 b2)) = sqrt (frominteger ((quadrat (a1 - b1)) + (quadrat (a2-b2)))) Grundlagen der Programmierung 2 (1.C)

67 Summentypen und Fallunterscheidung Summentyp: diese haben mehr als einen Konstruktor Beispiele: Bool mit True False data Wahrheitswerte = Wahr Falsch Aufzählungstyp: data Farben = Rot Gruen Blau Weiss Schwarz data Kontostand = Dm Integer Euro Integer Dollar Integer SFranken Integer Grundlagen der Programmierung 2 (1.C)

68 Liste als Summentyp selbstdefinierte Listen: data Liste a = Nil Cons a (Liste a) Listen-Definition in Haskell: data [a] = [] a : [a] Grundlagen der Programmierung 2 (1.C)

69 Funktionsdefinition mit mehreren Mustern: Beispiele: und1 Wahr Falsch = Falsch und1 Wahr Wahr = Wahr und1 Falsch Falsch = Falsch und1 Falsch Wahr = Falsch oder und2 Wahr x = x und2 Falsch x = Falsch oder und3 Wahr x = x und3 Falsch _ = Falsch -- Joker, Wildcard Grundlagen der Programmierung 2 (1.C)

70 Fallunterscheidung mit case Syntax: case Ausdruck of { Muster -> Ausdruck ;... ; Muster -> Ausdruck } Einschränkung: nur einfache Muster: K x 1... x n Kontextbedingung: die Muster müssen vom Typ her passen. Beispiel: und4 x y = case x of True -> y; False -> False Grundlagen der Programmierung 2 (1.C)

71 case: Gültigkeitsbereich, FV und GV F V (case s of (c 1 x x 1n1 t 1 );... ; (c k x k1... x knk t k )) = F V (s) F V (t 1 ) \ {x 11,... x 1n1 }... F V (t k ) \ {x k1,... x knk } GV(.) entsprechend Grundlagen der Programmierung 2 (1.C)

72 case: Gültigkeitsbereich und Beispiel F V (case x of True -> y; False -> False) = {x,y} F V (case x of (Punkt u v) -> u) = {x} GV (case x of (Punkt u v) -> u) = {u,v} Grundlagen der Programmierung 2 (1.C)