Grundlagen der Programmierung 2 (2.A)

Grundlagen der Programmierung 2
(2.A)
Prof. Dr. Manfred Schmidt-Schauß
Künstliche Intelligenz und Softwaretechnologie
2. Mai 2012
Listen und Listenfunktionen
Listen modellieren Folgen von gleichartigen, gleichgetypten Objekten.
Ausdruck im Programm
[0,1,2,3,4,5,6,7,8,9]
Erklärung
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 der Zahlen 1, 2, 3, ...
Grundlagen der Programmierung 2 (2.A) SS 2012
- 1 -
Listen und Listenfunktionen
zwei Schreibweisen für Listen:
[0, 1, 2]
schöne Darstellung
Druckbild einer Liste
(0 : (1 : (2 : [])))
interne Darstellung mit
zweistelligem Infix-Listen-Konstruktor : “
”
und dem Konstruktor []
Eingebaute, listenerzeugende Funktionen:
Ausdruck im Programm
[n..]
[n..m]
[1..10]
[n,m..k]
Grundlagen der Programmierung 2 (2.A) SS 2012
Erklärung
erzeugt die Liste der Zahlen ab n.
erzeugt die Liste von n bis m
ergibt [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
erzeugt die Liste von n bis k
mit Schritten m − n
- 2 -
Listen
• Listendarstellung
• Listenerzeugung
• Listen-Druckbild
Grundlagen der Programmierung 2 (2.A) SS 2012
- 3 -
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:[]
9:(8:[])
10:(9:(8:[]))
Liste [8] mit dem Element 8
Liste [9,8] mit zwei Elementen 8,9
Liste [10,9,8] mit drei Elementen
Grundlagen der Programmierung 2 (2.A) SS 2012
- 4 -
Baum-Bild einer Liste
||
||
|
|
||
|
||
||
|
|
|~ |
: ???
10
9
??
??
??
??
??
??
??
?










 
: >>>
8
>>
>>
>>
>>
>>
>>
>>
>
: ===
==
==
==
==
==
==
==
[]
entspricht [10, 9, 8]
Grundlagen der Programmierung 2 (2.A) SS 2012
- 5 -
Einfache Listenfunktionen
Definitionen
head (x:xs)
tail (x:xs)
= x
= xs
---
extrahiert das erste Element
extrahiert die Restliste
Auswertungen
Prelude>
?????
Prelude>
?????
Prelude>
?????
Prelude>
?????
head [] ←head [1] ←tail [] ←tail [1] ←-
Grundlagen der Programmierung 2 (2.A) SS 2012
- 6 -
Beispiel-Funktion Länge einer Liste
length :: [a] -> Int
length []
= 0
length (x:xs) = 1 + (length xs)
Auswertung
bei bereits ausgewerteter Liste
length (10:(9:(8:[])))
1+ (length (9:(8:[])))
1+(1+ (length (8:[])))
1+(1+ (1+ (length [])))
1+(1+ (1+ (0)))
3
Grundlagen der Programmierung 2 (2.A) SS 2012
Zweiter Fall; [10/x, (9:(8:[]))/xs]
Zweiter Fall; [9/x, (8:[])/xs]
Zweiter Fall; [8/x, ([])/xs]
Erster Fall;
3 Additionen
- 7 -
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 von =“ sind Muster(Pattern)
”
Z.B.
Muster
(x:xs)
und Argument (s:t)
ergibt die Ersetzung: [s/x, t/xs]
Grundlagen der Programmierung 2 (2.A) SS 2012
- 8 -
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 1 : map quadrat (2:[])
1*1 : map quadrat (2:[])
1 : map quadrat (2:[])
1 : (quadrat 2 : map quadrat [])
1 : (2*2 : map quadrat [])
1 : (4 : map quadrat [])
1 : (4 : [])
Grundlagen der Programmierung 2 (2.A) SS 2012
[quadrat/f, 1/x, (2:[])/xs]
bei vollst. Auswertung:
Zweite Gleichung
wg Interpreter
Erste Gleichung
= [1,4]
- 9 -
Auswertung: Wieviel ist nötig?
istLeer []
= True
istLeer (x:xs) = False
zahlenAb n
Auswertung
= n: zahlenAb (n+1)
(mit Listenerzeuger als Argument)
istLeer [1..]
istLeer (zahlenAb 1)
istLeer (1: zahlenAb (1+1))
False
Grundlagen der Programmierung 2 (2.A) SS 2012
verwende zahlenAb
Zweite Gleichung von istLeer
- 10 -
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 (2.A) SS 2012
- 11 -
Typen von Listenausdrücken
mapQuadrat xs = map quadrat
xs
*Main> :t mapQuadrat ←mapQuadrat :: forall a. (Num a) => [a] -> [a]
mapLength xs = map length
xs
*Main> :t mapLength ←mapLength :: forall a. [[a]] -> [Int]
Grundlagen der Programmierung 2 (2.A) SS 2012
- 12 -
Listenfunktion append
Die folgende Funktion hängt zwei Listen zusammen
(genauer: sie konstruiert diese Liste)
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 (2.A) SS 2012
- 13 -
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> [0..10000] ++ [10001..20000] == [0..20000] ←True
Grundlagen der Programmierung 2 (2.A) SS 2012
- 14 -
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:
*Main> 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 (2.A) SS 2012
- 15 -
Funktionen auf Listen
Die ersten n Elemente der Liste xs:
take
take
take
take
:: Int -> [a] -> [a]
0 _
= []
n []
= []
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 (2.A) SS 2012
- 16 -
Auswertungsreihenfolge, Definitionseinsetzung
Auswertung von
f s1 . . . sn
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 (2.A) SS 2012
- 17 -
Geschachtelte Pattern
nub (aus Module List) eliminiert doppelte, benachbarte Vorkommen
von Elementen aus Listen:
nub []
= []
nub [x]
= [x]
nub (x:(y:r)) = if x == y then
nub (y:r) else x : nub (y:r)
Beachte das Pattern (x:(y:r))
Grundlagen der Programmierung 2 (2.A) SS 2012
- 18 -
Listen: Auswertung
Listen (bzw. Listenargumente) nennt man:
einfach ausgewertet:
wenn Listen-Fallunterscheidung möglich ist,
d.h. [] oder von der Form s : t
vollständig ausgewertet:
wenn Liste endlich ist und
jeder Tail der Liste mindestens einfach ausgewertet und
alle Elemente ebenfalls vollständig ausgewertet sind,
Grundlagen der Programmierung 2 (2.A) SS 2012
- 19 -
Iterative Prozesse mit Listenargumenten
Bei Verwendung von Listenargumenten:
Die folgenden Begriffe sind unverändert:
linear rekursiv,
end-rekursiv
(= tail-recursive)
Baum-rekursiv
geschachtelt Baum-rekursiv
(Bei applikativer Reihenfolge der Auswertung)
iterativ muss angepasst werden.
Grundlagen der Programmierung 2 (2.A) SS 2012
- 20 -
Iterativer Auswertungsprozess zu f
Ein iterativer Auswertungsprozess liegt vor,
bei rekursiver Funktion f , wenn:
(f a1 . . . an)
∗
−
→
(3)
(f a1
(3)
. . . an )
(j)
und alle ai
∗
−
→
sind
(f a01 . . . a0n)
∗
−
→
......
∗
−
→
∗
−
→
(2)
(f a1
(m)
(f a1
(2)
. . . an )
(m)
. . . an
)
∗
−
→ ...
Basiswerte oder
komplett ausgewertete, endliche Listen
bei applikativer Reihenfolge der Auswertung
Grundlagen der Programmierung 2 (2.A) SS 2012
- 21 -
iterative Version fiter von f
fiter ist iterative Version von f
Wenn:
f und fiter das gleiche berechnen
und fiter einen iterativen Prozess erzeugt
(unter applikativer R.)
für alle Basiswerte und
alle komplett ausgewerteten endlichen Listen als Eingaben
Grundlagen der Programmierung 2 (2.A) SS 2012
- 22 -
Beispiel: iterative Version von length:
length_lin xs
= length_linr 0 xs
length_linr s []
= s
length_linr s (x:xs) = length_linr (s+1) xs
nicht-iterative Version:
length []
= 0
length (x:xs) = 1 + length xs
Grundlagen der Programmierung 2 (2.A) SS 2012
- 23 -
Linearer (Nicht-iterativer) Prozess zu length
length
(9:(8:(7:(6:...(1:[])))))
1+(length
(8:(7:(6:...(1:[]))))
1+(1+(length
(7:(6:...(1:[])))
1+(1+(1+(length
(6:...(1:[]))
..........
(1+(1+(1+(1+(1+(1+(1+(1+(1+0))))))))))
.....
9
Grundlagen der Programmierung 2 (2.A) SS 2012
- 24 -
Beispiel: iterativer Prozess
Beachte: wir benutzen hier die applikative Reihenfolge der Auswertung
length_lin
length_linr
length_linr
length_linr
length_linr
..........
length_linr
0
1
2
3
(9:(8:(7:(6:...(1:[])))))
(9:(8:(7:(6:...(1:[])))))
(8:(7:(6:...(1:[]))))
(7:(6:...(1:[])))
(6:...(1:[]))
9
Grundlagen der Programmierung 2 (2.A) SS 2012
[]
- 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 [a1, . . . , an] entspricht ((. . . ((e ⊗ a1) ⊗ a2) . . . ) ⊗ an).
foldr ⊗ e [a1, . . . , an] entspricht a1 ⊗ (a2 ⊗ (. . . (an ⊗ e)))
Grundlagen der Programmierung 2 (2.A) SS 2012
- 26 -
Definitionen der fold-Funktionen
foldl (Linksfaltung)
foldr (Rechtsfaltung)
foldl
:: (a -> b -> a) -> a -> [b] -> a
foldl f z []
= z
foldl f z (x:xs) = foldl f (f z x) xs
foldr
:: (a -> b -> b) -> b -> [a] -> b
foldr f z []
= z
foldr f z (x:xs) = f x (foldr f z xs)
Grundlagen der Programmierung 2 (2.A) SS 2012
- 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]
foldr (++) [] [[0],[2,3],[5]]
≡
≡
((((0+1)+2)+3)+4)
[0] ++ ([2,3] ++ ([5] ++ []))
Je nach Operator ist foldl, oder foldr besser geeignet.
Grundlagen der Programmierung 2 (2.A) SS 2012
- 28 -
Lokale Funktionsdefinitionen, anonyme Funktionen, Lambda-Ausdrücke
Lambda-Ausdruck
\x1 . . . xn -> hAusdrucki
x1, x2, ... sind die formalen Parameter
Beispiel
quadrat =
\x -> x*x
Der Lambdaausdruck kann wie eine Funktion verwendet werden
Grundlagen der Programmierung 2 (2.A) SS 2012
- 29 -
let und lokale Bindungen
let {x1 = s1; . . . ; xn = sn} in t
{x1 = s1; . . . ; xn = sn}
ist eine lokale Umgebung
die Variablen xi können in t vorkommen
mit der Bedeutung: Wert von si “
”
t
der eigentliche Ausdruck
let x1 = 5
x2 = "abc"
x3 = 7*x1
in (x1,x2,x3)
Grundlagen der Programmierung 2 (2.A) SS 2012
- 30 -
let und lokale Bindungen
In Haskell: rekursives let. D.h. xi kann in jedem sj vorkommen
Beachte im ghci-Interpreter: Spezielle Verwendung des let
Grundlagen der Programmierung 2 (2.A) SS 2012
- 31 -
Erweiterungen des let
Funktionen sind definierbar direkt in einem rekursiven let:
let {f x1 . . . xn = s; . . .} in t
Zum Beispiel:
let hochdrei x = x*x*x, a = 3 in hochdrei a
Grundlagen der Programmierung 2 (2.A) SS 2012
- 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 (2.A) SS 2012
- 33 -
Beispiel
\x-> x*x
Gültigkeitsbereich von x: der Ausdruck x*x
die Variable x ist gebunden von \x
x*x
in diesem Ausdruck ist x frei
Grundlagen der Programmierung 2 (2.A) SS 2012
- 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 t1 then t2 else t3) := F V (t1) ∪ F V (t2) ∪ F V (t3)
F V (\x1 . . . xn -> t) := F V (t) \ {x1, . . . , xn}
F V (let x1 = s1, . . . , xn = sn in t)
:= (F V (t) ∪ F V (s1) ∪ . . . ∪ F V (sn)) \ {x1, . . . , xn}
F V (let f x1 . . . xn = s in t)
:= F V (let f = \x1 . . . xn -> s in t)
Beachte:
FV ist eine Funktion auf dem Syntaxbaum
keine Haskell-Funktion
Grundlagen der Programmierung 2 (2.A) SS 2012
- 35 -
Beispiel: freie Variablen
F V (\x -> (f x y))
=
=
=
=
Grundlagen der Programmierung 2 (2.A) SS 2012
F V (f x y ) \ {x}
...
{x, f, y} \ {x}
{f, y}
- 36 -
Gebundene Variablen GV (t)
Entsprechend der F V -Definition:
•
•
•
•
•
•
GV (x) := ∅
GV ((s t)) := GV (s) ∪ GV (t)
GV (if t1 then t2 else t3) := GV (t1) ∪ GV (t2) ∪ GV (t3)
GV (\x1 . . . xn -> t) := GV (t) ∪ {x1, . . . , xn}
GV (let x1 = s1, . . . , xn = sn in t)
:= (GV (t) ∪ GV (s1) ∪ . . . ∪ GV (sn) ∪ {x1, . . . , xn}})
GV (let f x1 . . . xn = s in t)
:= GV (let f = \x1 . . . xn -> s in t)
= {f, x1, . . . , xn} ∪ GV (s) ∪ GV (t)
Auch hier
GV ist eine Funktion auf dem Syntaxbaum
keine Haskell-Funktion
Grundlagen der Programmierung 2 (2.A) SS 2012
- 37 -
Beispiel : Berechnung von gebundenen Variablen
GV(\x ->
(f x y))
=
=
=
=
Grundlagen der Programmierung 2 (2.A) SS 2012
GV (f x y) ∪ {x}
...
∅ ∪ {x}
{x}
- 38 -
Lexikalischer Gültigkeitsbereich einer Variablen
•
let x = s
•
\x y z -> t
in t
die Vorkommen der freien Variablen x in s, t
werden gebunden.
s, t ist der lexikalische Gültigkeitsbereich der
Variablen x
die freien Variablen x, y, z in t werden gebunden.
t ist der lexikalische Gültigkeitsbereich von x,
y, z.
Grundlagen der Programmierung 2 (2.A) SS 2012
- 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 (2.A) SS 2012
- 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.
Beispiel:
let x = (x*x) in (x+x)
führt zu Nichtterminierung des Haskell-Interpreters
ohne Reduktionen auszuführen.
Grundlagen der Programmierung 2 (2.A) SS 2012
- 41 -
Beispiel: Reihenfolgenunabhängigkeit der Bindungen
let
y = 20*z
x = 10+y
z = 15
in x
Wertet aus zu : 310.
Grundlagen der Programmierung 2 (2.A) SS 2012
- 42 -
Beispiel geschachtelte Bindungsbereiche
let {x = 1;y = 7}
in (let {y = 2; z = 4}
in (let z = 5
in (x+y+z)))
x = 1;y = 7
y = 2; z = 4
z = 5
x+y+z
Grundlagen der Programmierung 2 (2.A) SS 2012
- 43 -
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
= 1 + x*y
b
= 1 - y
in
x*a*a + y*b + a*b
Grundlagen der Programmierung 2 (2.A) SS 2012
- 44 -
Zusammengesetzte Daten-Objekte
Paar:
Beispiele
(1, 2)
(1, "hallo")
(1,(2,"hallo"))
Grundlagen der Programmierung 2 (2.A) SS 2012
(. . . , . . .)
(Paar von Zahl und Paar...)
- 45 -
n-Tupel von Objekten
n-Tupel sind Verallgemeinerung von Paaren (n ≥ 2)
(t1, . . . , tn)
ist n-Tupel von t1, . . . , tn
Beispiele
(1,2,3,True)
(1,(2,True),3)
("hallo",False)
(fakultaet 100,\x-> x)
Grundlagen der Programmierung 2 (2.A) SS 2012
- 46 -
Zusammengesetzte Objekte: Datentypen
Für Datentypen benötigt man:
Datenkonstruktor(en)
Datenselektor(en)
Beispiel
Paarkonstruktor
Paarselektoren
s, t −→ (s, t)
fst, snd
Eigenschaften:
fst(s, t) = s
snd(s, t) = t.
und
Grundlagen der Programmierung 2 (2.A) SS 2012
- 47 -
Beispiel n-Tupel
n-Tupelkonstruktor
t1, . . . , tn −→ (t1, . . . , tn)
Tupelselektoren
n Selektoren: pro Stelle ein Selektor
n-Tupel haben einen impliziten Konstruktor:
(., . . . , .)
| {z }
n
Grundlagen der Programmierung 2 (2.A) SS 2012
- 48 -
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 (2.A) SS 2012
- 49 -
Beispiel: Typen von Selektoren, Konstruktoren,
Tupeln
(1, 1)
::
(Integer, Integer)
(1, (2, True))
::
(Integer, (Integer, Bool))
(., . . . , .)
::
a1 → a2 → . . . → an → (a1, a2, . . . , an)
::
(a1, a2, a3) → a3
| {z }
n
selektiere_drittes_von_3
Grundlagen der Programmierung 2 (2.A) SS 2012
- 50 -
Benutzerdefinierte Konstruktoren
Definierbar in Haskell mittels data-Anweisung
Beispiel
data Punkt
= Punktkonstruktor Double Double
data Strecke
= Streckenkonstruktor Punkt Punkt
Punkt, Strecke:
Punktkonstruktor
Streckenkonstruktor
Double, Punkt (rechts)
Typen
Konstruktoren
Typen der Argumente
Grundlagen der Programmierung 2 (2.A) SS 2012
- 51 -
Muster (pattern)
streckenAnfang (Streckenkonstruktor x y) = x
Nutzen der Muster:
•
•
tiefes Selektieren
Ersatz für Selektoren
Syntax der Muster:
hMusteri ::= hVariablei | (hMusteri)
| hKonstruktor(n)i hMusteri . . . hMusteri
|
{z
n
}
| (hMusteri, . . . , hMusteri)
Bedingung: in einem Muster darf keine Variable doppelt vorkommen
Grundlagen der Programmierung 2 (2.A) SS 2012
- 52 -
Muster; 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)}
Programm dazu
testfu (x,y,u) = show (x,y,u)
Grundlagen der Programmierung 2 (2.A) SS 2012
in ...
Aufruf:
testfu (1,2,(4,5)) testfu (1,2,(4,5))
- 53 -
Benutzerdefinierte Typnamen mit Parametern
Beispiel Punkt, Strecke, Polygonzug
data
data
data
data
Punkt a
Strecke a
Vektor a
Polygon a
=
=
=
=
Punkt a a
Strecke (Punkt a) (Punkt a)
Vektor a 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 (2.A) SS 2012
- 54 -
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 (2.A) SS 2012
- 55 -
Summentypen und Fallunterscheidung
Summentypen: diese haben mehr als einen Konstruktor
Beispiele: Bool mit True False
data
Bool = True | False
Aufzählungstyp:
data Farben = Rot | Gruen | Blau | Weiss | Schwarz
data Kontostand =
Euro Integer | Dollar
| SFranken Integer
Grundlagen der Programmierung 2 (2.A) SS 2012
Integer
- 56 -
Liste als Summentyp
selbstdefinierte Listen:
Typvariable
data Liste a = Nil | Cons a (Liste a)
Typkonstruktor
Typ erstes Arg
Konstruktor1
Typ zweites Arg
Konstruktor2
Listen-Definition in Haskell:
data [a] = [] |
a : [a]
Grundlagen der Programmierung 2 (2.A) SS 2012
- 57 -
Fallunterscheidung mit case
Syntax:
case hAusdrucki of {h Musteri -> hAusdrucki; . . . ;hMusteri -> hAusdrucki}
Einschränkung:
Kontextbedingung:
nur einfache Muster: K x1 . . . xn
die Muster müssen vom Typ her passen.
Beispiel:
und
x y
= case x of True -> y; False -> False
Grundlagen der Programmierung 2 (2.A) SS 2012
- 58 -
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 (2.A) SS 2012
- 59 -
Reduktionsregel zum case
case-Reduktion (zusätzliche Reduktionsregel)
(case (c t1 . . . tn) of . . . (c x1 . . . xn → s) . . .)
s[t1/x1, . . . , tn/xn]
Grundlagen der Programmierung 2 (2.A) SS 2012
- 60 -
Beispiel-Verwendung (Entzuckerung)
map f []
map f (x:xs)
= []
= f x : map f xs
kann man auch programmieren mittels:
map f lst
= (case lst of [] -> []; (x:xs) -> f x : map f xs)
Grundlagen der Programmierung 2 (2.A) SS 2012
- 61 -
Bemerkungen zur Auswertung
•
Normale und verzögerte Reihenfolge der Auswertung
reduzieren nicht die Argumente von Konstruktoren
⇒
Dadurch kann man (potentiell) unendliche Listen verarbeiten
Beispiele:
(1+2):[]
1:repeat 1
Tests:
wird nicht reduziert: ist ein Wert
wird nicht reduziert: ist ein Wert
seq (1:repeat 1) 7
seq (bot:repeat 1) 8
Grundlagen der Programmierung 2 (2.A) SS 2012
- 62 -