Praktische Informatik 3: Funktionale Programmierung Vorlesung 5 vom 13.11.2012: Funktionen Höherer Ordnung I
Christoph Lüth Universität Bremen Wintersemester 2012/13
Rev. 1872 1 [29]
Fahrplan
I Teil I: Funktionale Programmierung im Kleinen
IEinführung
IFunktionen und Datentypen
IRekursive Datentypen
ITypvariablen und Polymorphie
IFunktionen höherer Ordnung I
IFunktionen höherer Ordnung II
ITypinferenz
I Teil II: Funktionale Programmierung im Großen I Teil III: Funktionale Programmierung im richtigen Leben
2 [29]
Inhalt
I Funktionenhöherer Ordnung
I Funktionen alsgleichberechtigte Objekte
I Funktionen alsArgumente
I Spezielle Funktionen:map,filter,foldund Freunde
3 [29]
Ähnliche Funktionen der letzten Vorlesung
I Pfade:
c a t :: Path→ Path→ Path
c a t Mt p =p
c a t ( Cons p p s ) q s =Cons p ( c a t p s q s ) r e v :: Path→ Path
r e v Mt =Mt
r e v ( Cons p p s ) = c a t ( r e v p s ) ( Cons p Mt ) I Zeichenketten:
c a t :: M y S t r i n g→ M y S t r i n g→ M y S t r i n g
c a t Empty t = t
c a t ( Cons c s ) t = Cons c ( c a t s t ) r e v :: M y S t r i n g→ M y S t r i n g
r e v Empty = Empty
r e v ( Cons c t ) = c a t ( r e v t ) ( Cons c Empty ) Gelöst durch Polymorphie
4 [29]
Ähnliche Funktionen der letzten Vorlesung
k a s s e :: E i n k a u f s w a g e n→ I n t k a s s e L e e r e r W a g e n =0
k a s s e ( E i n k a u f a m e ) = c e n t a m+ k a s s e e i n v e n t u r :: L a g e r→ I n t
i n v e n t u r L e e r e s L a g e r = 0
i n v e n t u r ( L a g e r a m l ) = c e n t a m+ i n v e n t u r l l e n :: M y S t r i n g→ I n t
l e n Empty = 0
l e n ( Cons c s t r ) = 1+ l e n s t r Gemeinsamkeiten:
I ein Fall pro Konstruktor I linearerrekursiver Aufruf
I durch Polymorphienichtgelöst (InstanzeinerDefinition)
5 [29]
Muster der primitiven Rekursion
I Anwenden einer Funktion aufjedes Element der Liste
I möglicherweiseFilternbestimmter Elemente
I Kombinationder Ergebnisse zu einem GesamtergebnisE
x
1x
2x
3x
4E
6 [29]
Ein einheitlicher Rahmen
I Beispiele:
t o L :: S t r i n g→ S t r i n g
t o L [ ] = [ ]
t o L ( c : c s ) =
t o L o w e r c : t o L c s
toU :: S t r i n g→ S t r i n g
toU [ ] = [ ]
toU ( c : c s ) =
t o U p p e r c : t o L c s I Warum nicht . . .
map f [ ] = [ ]
map f ( c : c s ) = f c : map f c s t o L c s =map t o L o w e r c s toU c s =map t o U p p e r c s I FunktionfalsArgument I Was hättemapfür einenTyp?
7 [29]
Funktionen Höherer Ordnung
Slogan
“Functions are first-class citizens.”
I Funktionen sindgleichberechtigt: Ausdrücke wiealle anderen
I Grundprinzipder funktionalen Programmierung
I Modellierungallgemeiner Berechungsmuster
I Kontrollabstraktion
8 [29]
Funktionen als Argumente: map
I mapwendet Funktion auf alle Elemente an I Signatur:
map :: (α→ β)→ [α]→ [β] I Definition wie oben
map f [ ] = [ ]
map f ( x : x s ) = f x : map f x s I Auswertung (wie vorher):
toL "ABC" map toLower (’A’:’B ’:’ C’:[ ]) toLower ’A’ : map toLower (’B’:’C’:[ ]) . . . ’a ’:’ b ’:’ c ’ : map toLower[ ]
’a ’:’ b ’:’ c ’: [ ]="abc"
I Funktionsausdrückereduzieren durchApplikation
9 [29]
Funktionen als Argumente: filter
I Elementefiltern:filter I Signatur:
f i l t e r :: (α→ B o o l )→ [α]→ [α]
I Definition
f i l t e r p [ ] = [ ] f i l t e r p ( x : x s )
| p x = x : f i l t e r p x s
| o t h e r w i s e = f i l t e r p x s I Beispiel:
l e t t e r s :: S t r i n g→ S t r i n g l e t t e r s = f i l t e r i s A l p h a
10 [29]
Beispiel filter: Primzahlen
I Sieb des Erathostenes
I Für jedegefundene PrimzahlpalleVielfachenheraussieben
I Dazu:filternmit\n→mod n p/=0!
I Namenlose(anonyme) Funktion
s i e v e :: [ I n t e g e r ]→ [ I n t e g e r ] s i e v e [ ] = [ ]
s i e v e ( p : p s ) =
p : s i e v e ( f i l t e r ( \n→ mod n p /= 0 ) p s ) I Primzahlen im Intervall[1.. n]:
p r i m e s T o :: I n t e g e r→ [ I n t e g e r ] p r i m e s T o n = s i e v e [ 2 . . n ] I Die erstennPrimzahlen:
p r i m e s :: I n t→ [ I n t e g e r ] p r i m e s n= t a k e n ( s i e v e [ 2 . . ] )
11 [29]
Funktionen als Argumente: Funktionskomposition
I Funktionskomposition(mathematisch)
(◦) :: (β→ γ) → (α→ β)→ α→ γ
( f ◦g ) x = f ( g x )
IVordefiniert
ILies:fnachg
I Funktionskompositionvorwärts:
(>.>) :: (α→ β)→ (β→ γ)→ α→ γ ( f >.> g ) x =g ( f x )
INichtvordefiniert!
12 [29]
η-Kontraktion
I Vertauschen derArgumente(vordefiniert):
f l i p :: (α→ β→ γ)→ β→ α→ γ
f l i p f b a= f a b
I Damit Funktionskomposition vorwärts:
(>.>) :: (α→ β)→ (β→ γ)→ α→ γ (>.>) = f l i p (◦)
I Da fehlt doch was?! Nein:
(>.>)=flip (◦) ≡ (>.>) f g a=flip (◦) f g a
I η-Kontraktion (η-Äquivalenz)
I Bedingung:E:: α→β,x:: α,Edarfxnicht enthalten λx→E x ≡ E
I Syntaktischer SpezialfallFunktionsdefinition(punktfreie Notation)
f x=E x ≡ f=E
13 [29]
Partielle Applikation
I Funktionskonstruktorrechtsassoziativ:
a→b→c≡a→(b→c)
IInbesondere:(a→b)→c6=a→(b→c) I Funktionsanwendung istlinksassoziativ:
f a b≡( f a) b
IInbesondere:f (a b)6=( f a) b I PartielleAnwendung von Funktionen:
IFürf :: a→b→c,x :: aistf x :: b→c(closure) I Beispiele:
Imap toLower::String→String
I (3==)::Int→Bool
Iconcat◦map ( replicate 2) :: String→String
14 [29]
Einfache Rekursion
I Einfache Rekursion: gegeben durch
I eine Gleichungfür dieleere Liste
I eine Gleichungfür dienicht-leere Liste (miteinemrekursiven Aufruf)
I Beispiel:kasse,inventur,sum,concat,length, (++), . . .
I Auswertung:
sum [4,7,3] 4 + 7 + 3 + 0
concat [A, B, C] A++B++C++ [ ]
length [4, 5, 6] 1+ 1+ 1+ 0
x1 x2 x3 x4
E
15 [29]
Einfache Rekursion
I Allgemeines Muster:
f [] = A
f (x:xs) = x⊗f xs I Parameterder Definition:
IStartwert (für die leere Liste)A::b
IRekursionsfunktion⊗:: a -> b-> b I Auswertung:
f [x1,..., xn]=x1⊗x2⊗. . .⊗xn⊗A I Terminiertimmer (wenn Listeendlichund⊗,Aterminieren) I Entspricht einfacherIteration(while-Schleife)
16 [29]
Einfach Rekursion durch foldr
I EinfacheRekursion
I Basisfall: leere Liste
I Rekursionsfall: Kombination aus Listenkopf und Rekursionswert
I Signatur
f o l d r :: (α→ β→ β)→ β→ [α]→ β I Definition
f o l d r f e [ ] = e
f o l d r f e ( x : x s ) = f x ( f o l d r f e x s )
17 [29]
Beispiele: foldr
I Summierenvon Listenelementen.
sum :: [ I n t ]→ I n t sum x s = f o l d r (+) 0 x s I Flachklopfenvon Listen.
c o n c a t :: [ [ a ] ]→ [ a ] c o n c a t x s = f o l d r (++) [ ] x s I Längeeiner Liste
l e n g t h :: [ a ]→ I n t
l e n g t h x s = f o l d r (λx n→ n+ 1 ) 0 x s
18 [29]
Beispiele: foldr
I Kasse:
type E i n k a u f s w a g e n = [ ( A r t i k e l , Menge ) ] k a s s e :: E i n k a u f s w a g e n→ I n t
k a s s e = f o l d r (λ( a , m) r→ c e n t a m+ r ) 0
I Inventur
type L a g e r = [ ( A r t i k e l , Menge ) ] i n v e n t u r :: L a g e r→ I n t
i n v e n t u r = f o l d r (λ( a , m) r→ c e n t a m+ r ) 0
19 [29]
Noch ein Beispiel: rev
I Listenumdrehen:
r e v :: [ a ]→ [ a ]
r e v [ ] = [ ]
r e v ( x : x s ) = r e v x s ++ [ x ] I Mitfold:
r e v x s = f o l d r s n o c [ ] x s s n o c :: a→ [ a ]→ [ a ] s n o c x x s = x s ++ [ x ] I Unbefriedigend: doppelte Rekursion
20 [29]
Einfache Rekursion durch foldl
I foldrfaltet vonrechts:
foldr⊗[x1, ...,xn]A=x1⊗(x2⊗(. . .(xn⊗A))) I Warum nichtandersherum?
foldl⊗[x1, ...,xn]A= (((A⊗x1)⊗x2). . .)⊗xn I Definition vonfoldl:
f o l d l :: (α → β → α) → α → [β] → α
f o l d l f a [ ] =a
f o l d l f a ( x : x s ) = f o l d l f ( f a x ) x s
21 [29]
Beispiel: rev revisited
I Listenumkehr ist faltenvon links:
r e v ’ x s = f o l d l ( f l i p ( : ) ) [ ] x s
I Nur nocheineRekursion
22 [29]
foldr vs. foldl
I f=foldr⊗Aentspricht
f [] = A
f (x:xs) = x⊗f xs
I Kann nicht-strikt inxssein, z.B.and,or I f=foldl⊗Aentspricht
f xs = g A xs
g a [] = a
g a (x:xs) = g(a⊗x)xs
I Endrekursiv(effizient), aber strikt inxs
23 [29]
foldl = foldr
Definition (Monoid) (⊗,A)ist einMonoidwenn
A⊗x=x (Neutrales Element links) x⊗A=x (Neutrales Element rechts) (x⊗y)⊗z=x⊗(y⊗z) (Assoziativät) Theorem
Wenn(⊗,A)Monoid, dann für alleA,xs foldl⊗Axs=foldr⊗Axs
I Beispiele:length,concat,sum I Gegenbeispiel:rev
24 [29]
Funktionen Höherer Ordnung: Java
I Java: keine direkte Syntax für Funktionen höherer Ordnung I Folgendes istnichtmöglich:
i n t e r f a c e C o l l e c t i o n {
O b j e c t f o l d ( O b j e c t f ( O b j e c t a , C o l l e c t i o n c ) , O b j e c t a ) }
I Aber folgendes:
i n t e r f a c e F o l d a b l e { O b j e c t f ( O b j e c t a ) ; } i n t e r f a c e C o l l e c t i o n {
O b j e c t f o l d ( F o l d a b l e f , O b j e c t a ) ; } I VergleicheIteratoraus Collections Framework (Java SE 6):
p u b l i c i n t e r f a c e I t e r a t o r<E>
b o o l e a n h a s N e x t ( ) ; E n e x t ( ) ; }
25 [29]
Funktionen Höherer Ordnung: C
I Implizitvorhanden: Funktionen = Zeiger auf Funktionen t y p e d e f s t r u c t l i s t _ t {
v o i d ∗e l e m ;
s t r u c t l i s t _ t ∗n e x t ; } ∗l i s t ;
l i s t f i l t e r (i n t f (v o i d ∗x ) , l i s t l ) ; I KeinedirekteSyntax (e.g. namenlose Funktionen) I Typsystem zuschwach(keine Polymorphie) I Benutzung:signal(C-Standard 7.14.1)
#i n c l u d e <s i g n a l . h>
v o i d (∗s i g n a l (i n t s i g , v o i d (∗f u n c ) (i n t) ) ) (i n t) ;
26 [29]
Funktionen Höherer Ordnung: C
Implementierung vonfilter:
l i s t f i l t e r (i n t f (v o i d ∗x ) , l i s t l ) { i f ( l ==NULL ) {
r e t u r n NULL ; }
e l s e { l i s t r ;
r= f i l t e r ( f , l→ n e x t ) ; i f ( f ( l→ e l e m ) ) {
l→n e x t= r ; r e t u r n l ; }
e l s e { f r e e ( l ) ; r e t u r n r ;
} } }
27 [29]
Übersicht: vordefinierte Funktionen auf Listen II
map :: (α→ β)→ [α]→ [β] −−Auf alle anwenden f i l t e r :: (α→ B o o l )→ [α]→ [α] −−Elemente filtern f o l d r :: (α→ β→ β)→ β→ [α]→ β −−Falten v. rechts f o l d l :: (β→ α→ β)→ β→ [α]→ β −−Falten v. links t a k e W h i l e :: (α→ B o o l )→ [α]→ [α]
d r o p W h i l e :: (α→ B o o l )→ [α]→ [α]
−−takeWhile ist längster Prefix so dass p gilt, dropWhile der Rest any :: (α → B o o l ) → [α] → B o o l −−p gilt mind. einmal a l l :: (α → B o o l ) → [α] → B o o l −−p gilt für alle e l e m :: ( Eq α) ⇒ α → [α] → B o o l −−Ist enthalten?
z i p W i t h :: (α → β → γ) → [α] → [β] → [γ]
−−verallgemeinertes zip
28 [29]
Zusammenfassung
I Funktionenhöherer Ordnung
I Funktionen alsgleichberechtigte ObjekteundArgumente
I Partielle Applikation,η-Kontraktion, namenlose Funktionen
I Spezielle Funktionen höherer Ordnung:map,filter,foldund Freunde I Formen derRekursion:
I EinfacheRekursion entsprichtfoldr
29 [29]