7 Funktionaler Programmierstil und Rekursion (2. Teil) 7.7 Formen ...

Peter Hubwieser Ablaufmodellierung WS 2002/03 

KAPITEL 7: Funktionaler Programmierstil (2) LERNINHALTE V 1.0 Seite 1 

7 Funktionaler Programmierstil und Rekursion (2. Teil) 

7.7 Formen der Rekursion 

Die Anwendung und die Effizienz rekursiver Funktionen hängt sehr stark von der Struktur der 

Rekursion ab: rekursive Funktionsanwendungen erzeugen ja neue Prozesse, die in der Regel 

die Struktur der Berechnung (zumindest vorübergehend) komplizierter machen. Leider beschränken 

sich dabei nicht alle rekursiven Funktionen auf so einfache Veränderungen der 

Berechnungsstruktur wie fak (siehe Abschnitt 7.5.3) oder ggT (siehe Abschnitt 7.5). In der 

Tat gehören die beiden Funktionen zu einer Klasse rekursiver Funktionen mit relativ einfacher 

Struktur (linear rekursive Funktionen). 

7.7.1 Lineare Rekursion 

Eine rekursive Funktionsdeklaration heißt linear rekursiv, falls in jedem Fallunterscheidungszweig 

höchstens ein rekursiver Aufruf der Funktion enthalten ist. Aus der Sicht unserer 

dynamischen Datenflussdiagramme enthält dann jedes Diagramm maximal einen Prozess dieser 

Funktion. Beispiele dafür sind, wie schon erwähnt, die Funktionen fak und ggT. 

Besonders einfach (und daher sehr effizient zu berechnen) sind linear rekursive Funktionen, 

bei deren Berechnung die rekursiven Aufrufe immer der letzte Verarbeitungsschritt sind, wie 

z.B. in ggT (siehe Abbildung 1). Solche Funktionen nennt man repetitiv rekursiv. 

Auswertung 

18 12 18-12 12 

6 12-6 

ggT ggT 

Abbildung 1: Dynamisches Datenflussdiagramm für ggT 

ggT 

6 

Struktur 

m n 

ggT 

falls m=n 

falls m>n 

falls m



7.7.2 Kaskadenartige Rekursion 

Die Definition von linearer Rekursion legt die Vermutung nahe, dass es auch Funktionen gibt, 

die in mindestens einem Fallunterscheidungszweig mehr als einen rekursiven Aufruf enthalten. 

In solchen Fällen spricht man von kaskadenartiger Rekursion. 

Dazu ein Beispiel: 

Die Binomialkoeffizienten bn(n,k) (oft auch „n über k“ gesprochen) haben für vielen Anwendungen 

aus der Kombinatorik und Wahrscheinlichkeitsrechnung große Bedeutung. So 

beträgt beispielsweise die Wahrscheinlichkeit eines 6-ers im Lotto 1/bn(49,6). Wenn man 

Potenzen von Binomen (a + b) n ausmultipliziert, dann kommen die Binomialkoeffizienten als 

konstante Faktoren vor, z.B. für n=4 als Faktoren 1, 4, 6, 4, 1: 

(a + b) 4 = 1a 4 + 4a 3 b + 6a 2 b 2 + 4ab 3 + 1b 4 . 

Die Berechnung dieser Binomialkoeffizienten führt uns auf eine Funktionsdeklaration, in der 

ein rekursiver Aufruf zwei neue Prozesse erzeugt. Zur Herleitung der Deklaration betrachten 

wir zunächst das Pascalsche Dreieck, in dem sie sich die Binomialkoeffizienten sehr übersichtlich 

anordnen lassen (siehe Abbildung 2). 

1 

1 1 

1 2 1 

1 3 3 1 

1 4 

+ 

6 4 1 

Abbildung 2: Das Pascalsche Dreieck zur Berechnung der Binomialkoeffizienten 

Zur Erzeugung dieses Dreiecks gelten die folgenden Vorgaben (s. a. die folgende Tabelle): 

1) Der Index k der Spalten läuft von 0 bis zum jeweiligen Zeilenindex n. 

2) An den äußersten Positionen steht (k = 0 und k = n) steht immer der Wert 1, also: 

bn(n, 0) = bn(n, n ) = 1 für alle n. 

3) Die „inneren“ Zahlen (0 < k < n) lassen sich folgendermaßen aus denen der darüber 

liegenden Zeile berechnen: bn(n, k) = bn(n–1, k) + bn(n–1, k–1). Bitte beachte Sie dazu 

auch das in der folgenden Tabelle grau gekennzeichnete Beispiel zur Berechnung 

von bn(5, 2). 

k = 0 k = 1 k = 2 k = 3 k = 4 k = 5 

n = 0 1 

n = 1 1 1 

n = 2 1 2 1 

n = 3 1 3 3 1 

n = 4 1 4 6 4 1 

n = 5 1 5 10 10 5 1 

usw.



Damit haben wir auch schon die Struktur für unserer rekursive Funktion abgeleitet: 

function bn (nat n,k): nat 

return if n=0 or k=0 or k=n then 1 else bn(n–1, k) + bn(n–1, k–1) fi 

Dabei gelten immer die Nebenbedingung n ≥ k und n, k ≥ 0. 

Dieses Rekursionsschema führt z.B. für „4 über 3“ zu folgender Berechnungsfolge: 

bn(5,3) = 

bn(4,3) + bn(4,2) = 

bn(3,3) + bn(3,2) + bn(3,2) + bn(3,1) = 

1 + bn(2,2) + bn(2,1) + bn(2,2) + bn(2,1) + bn(2,1) + bn(2,0) = 

1 + 1 + bn(1,1) + bn(1,0) + 1 + bn(1,1) + bn(1,0) + bn(1,1) + bn(1,0) + 1 = 

1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 = 

10 

Kaskadierende Rekursionsaufrufe vervielfachen die Zahl der aktiven Prozesse und sind daher 

für die Laufzeit eines Algorithmus von erheblicher Bedeutung. Zudem werden in diesem Fall 

viele Funktionen mehrmals benötigt (unterstrichen), ohne dass ihre Ergebnisse dafür zwischendurch 

aufbewahrt würden. Dieselbe Berechnung wird daher u.U. mehrfach ausgeführt 

(z.B. wird in unserem obigen Ablauf bn(2,1) dreimal berechnet). Dieses Verfahren ist also 

sicher nicht sehr effizient. 

Struktur 

n k 

bn 

5 3 

bn 

n 0 UND 

k0 UND k



bn(3,3) 

bn(4,3) 

bn(2,2) 

bn(3,2) 

bn(2,1) 

bn(5,3) 

bn(2,2) 

bn(3,2) 

bn(4,2) 

bn(3,1) 

bn(2,1) bn(2,1) bn(2,0) 

bn(1,1) bn(1,0) bn(1,1) bn(1,0) bn(1,1) bn(1,1) 

Abbildung 4: Aufrufbaum für bn(5,3) 

7.7.3 Vernestete Rekursion 

Die kompliziertesten Aufrufstrukturen entstehen, wenn die rekursiven Aufrufe der Funktion 

in den Parameterlisten weitere rekursive Aufrufe enthalten. Solche Funktionen heißen vernestet 

rekursiv. 

Beispiel: 

Die wegen ihrer sehr interessanten Eigenschaften bekannte Ackermann-Funktion enthält (neben 

weiteren rekursiven Aufrufen im Rumpf) einen solchen Aufruf in der Parameterliste (unterstrichen). 

Zunächst die mathematische Definition: 

acker(0, n) = n+1 

acker(m, 0) = acker(m–1, 1) 

acker(m,n) = acker (m–1, acker (m, n–1)) , falls m>0 und n>0. 

In FPPS programmiert: 

function acker(nat m, n): nat 

return if m=0 then n+1 else if n=0 then acker (m–1, 1) else acker (m–1, acker (m, n–1)) fi fi 

Die Auswertung der Ackermann-Funktion zeigen wir exemplarisch am Beispiel acker(3,2): 

acker(3,2) = 

acker(2, acker(3,1)) = 

acker(2, acker(2, acker(3,0))) = 

acker(2, acker(2, acker(2,1))) = 

acker(2, acker(2, acker(1, acker(2,0)))) = 

acker(2, acker(2, acker(1, acker(1,1)))) = 

acker(2, acker(2, acker(1, acker(0, acker(1,0))))) = 


acker(2, acker(2, acker(1, acker(0, 2)))) = 

acker(2, acker(2, acker(1, 3))) = 

acker(2, acker(2, acker(0, acker(1,2)))) =




acker(2, acker(2, acker(0, acker(0, acker(0, acker(1,0)))))) = 

acker(2, acker(2, acker(0, acker(0, acker(0, acker(0,1))))))= 

acker(2, acker(2, acker(0, acker(0, acker(0, 2))))) = 

acker(2, acker(2, acker(0, acker(0, 3)))) = 

acker(2, acker(2, acker(0, 4))) = 

acker(2, acker(2, 5)) = usw. 

Wie man sieht, führen bereits Aufrufe mit sehr niedrigen Parameterwerten zu sehr langen 

Auswertungen, die wir hier gar nicht in voller Länge zeigen wollen. 

Abbildung 5 zeigt die Auswertung von acker(3,2) im dynamischen Datenflussdigramm. Man 

beachte dabei die Verkettung unausgewerteter Funktionsaufrufe (als wartender Prozesse), die 

zu einem hohen Verbrauch an Ressourcen führt. 

m 

3 

acker 

m=0 

n+1 

acker 

n 

2 

n=0 

Auswertung 

m0 UND 

n0 

m-1 

acker 

2 

1 

3 

acker 

m-1 

acker 

m n-1 

acker 

1 

acker 

2 

2 

acker 

3 

acker 

acker 

0 

2 

2 

acker 

acker 

acker 

Abbildung 5: : Dynamisches Datenflussdiagramm für die Ackermannfunktion 

2 

1 

2 

2 

acker 

1 

acker 

2 0 

acker 

acker 

usw. 

Die folgende Tabelle zeigt anhand einiger Werte für ausgewählte Argumente, dass die Ackermannfunktion 

enorm schnell wächst. Dieses sehr schnelle Wachstum (verbunden mit der 

langen Auswertungsfolge) ist auch genau der Grund für das Interesse an dieser Funktion. Es 

führt dazu, dass sich die Anzahl der notwendigen Berechnungen nicht vor dem jeweiligen 

Aufruf durch eine Konstante abschätzen lässt. Daher gehört die Ackermannfunktion nicht zur 

Klasse der primitiv rekursiven Funktionen, deren Wert sich (imperativ) durch Verwendung 

von Wiederholungen mit fester Wiederholungszahl berechnen lässt. Mehr darüber erfahren 

Sie im Modul „Theoretische Informatik“ unter dem Stichwort „Klassen berechenbarer Funktionen“.



acker(m,n) n = 0 n = 1 n = 2 n = 3 

m = 0 1 2 3 4 

m = 1 2 3 4 5 

m = 2 3 5 7 9 

m = 3 5 13 29 61 

m = 4 13 65533 2 65536 -3 2 265536 -3 

m = 5 65533 acker(4,65533) acker(4,acker(4,65533)) acker(4,acker(5,2)) 

m = 6 acker(4,65533) acker(5,acker(4,65533)) acker(5,acker(6,1)) acker(5,acker(6,2)) 

(nach http://www-users.cs.york.ac.uk/~susan/cyc/a/ackermnn.htm) 

7.7.4 Verschränkte Rekursion 

Die bisherigen Betrachtungen legen den Schluss nahe, dass eine Funktionsdeklaration genau 

dann als rekursiv bezeichnet werden kann, wenn sich in ihrem Rumpf mindestens ein Aufruf 

derselben Funktion findet. Leider werden damit nicht alle rekursiven Funktionen erfasst, denn 

es gibt noch die Möglichkeit, dass eine Funktion einen rekursiven Aufruf gewissermaßen im 

Umweg über den Aufruf einer anderen Funktion (oder sogar einer Folge solcher Aufrufe) 

„versteckt“. Wenn die Rekursion über mehrere Stufen laufen soll, muss diese andere Funktion 

(bzw. die letzte in der Folge der anderen aufgerufenen Funktionen) wiederum einen Aufruf 

der ursprünglichen Funktion beinhalten. Ein System solcher Funktionen heißt dann verschränkt 

rekursiv. 

Beispiel (gerade oder ungerade Zahlen): 

Intuitiv kann man die Eigenschaft einer natürlichen Zahl n≥1, gerade oder ungerade zu sein, 

folgendermaßen definieren: 

• 1 ist ungerade, 

• n>1 ist genau dann gerade, wenn n-1 ungerade ist. 

• n>1 ist genau dann ungerade, wenn n-1 gerade ist. 

Daraus lässt sich nun leicht ein System aus zwei verschränkt rekursiven Funktionen ableiten: 

function gerade (nat n): bool 

return if n = 1 then false else ungerade(n-1) fi 

function ungerade (nat n): bool 

return if n = 1 then true else gerade(n-1) fi 

Für den Wert n=3 erhält man folgende Aufrufe: 

gerade(3) = ungerade(2) = gerade(1) = false 

ungerade(3) = gerade(2) = ungerade(1) = true 

Ein System verschränkt rekursiver Funktionen liegt also vor, falls die Deklarationen dieser 

Funktionen zu einer zyklischen Folge von Aufrufen führen. Dies kann man anhand des Stützgraphen 

dieses Systems feststellen. Dabei werden die Funktionen als Knoten des Graphen 

aufgefasst und Aufrufe von Funktionen (im Rumpf von Deklarationen) als gerichtete Kanten.



Beispiel 1 (Fakultät): 

- 

fak * 

= 

Beispiel 2 (gerade/ungerade): 

gerade 

- 

= 

ungerade 

Rekursion tritt in einem System von Funktionen genau dann auf, wenn der Stützgraph dieses 

Systems einen Zyklus beinhaltet. Verschränkt ist eine Rekursion genau dann, wenn ihr Zyklus 

mehr als eine Funktion beinhaltet. 

7.8 Funktionen höherer Ordnung 

Einer der wesentlichen Vorteile funktionaler Programmiersprachen ist die Möglichkeit, Funktionen 

ähnlich zu behandeln wie „normale“ Datentypen. Funktionen werden in funktionalen 

Sprachen als (mit allen anderen gleichberechtigte) Datenobjekte angesehen. Daher können 

Funktionen auch als Argumente oder Rückgabewerte anderer Funktionen verwendet werden, 

was viele Berechnungen stark vereinfacht. Funktionen, die andere Funktionen als Argumente 

verwenden oder zurückgeben, heißen Funktionen höherer Ordnung oder Funktionale. 

Funktionale Programmiersprachen heißen übrigens u.a. auch deswegen so, weil sie Funktionen 

ebenso als „Daten erster Ordnung“ behandeln wie alle andere Sorten. 

Ein Beispiel dazu aus der Mathematik: 

Der Ableitungsoperator abl (meist durch ´ bzw. d/dx bei Ableitung nach x symbolisiert) ist 

ein Funktional, das als Eingabe eine Funktion erhält und deren Ableitungsfunktion zurückliefert, 

z.B. angewandt auf die Quadratfunktion: 

f(x) = x 2 ; abl(f(x)) = f´(x) = 2x. Hier wird also jede (differenzierbare) Funktion f(x) auf ihre 

Ableitungsfunktion f´(x) abgebildet: 

abl: f(x) → f´(x). 

7.8.1 Funktionen als Argumente 

Zur Erklärung der Verwendung von Funktionen als Argumente anderer Funktionen wollen 

wir einige „Universalfunktionen“ auf Listen behandeln, die in den meisten funktionalen Sprachen 

bereits vordefiniert sind.



Beispiel (Anwendung einer Funktion auf eine Liste): 

Sehr praktisch ist das in vielen funktionalen Sprachen eingebaute Funktional map, das als 

Argumente eine Funktion f und eine Liste lin erhält und eine Liste lout zurückliefert, die 

durch die Anwendung der Funktion f auf alle Elemente der Liste lin entsteht, z.B. mit f = sin 

und lin = [pi/3,pi/2,pi]: 

map (sin, [pi/3,pi/2,pi]) = [0.866025, 1.0, -8.74228e-008] 

Zur Definition vom Funktionalen in FPPS müssen wir die Syntax der Funktionsdeklaration 

erweitern: Wir lassen nun auch Funktionssorten in den Parameterlisten und im Ergebnis der 

Funktion zu. Dabei soll z.B. nat → nat eine Funktion symbolisieren, die natürliche Zahlen als 

Argumente übernimmt und Werte dieser Sorte zurückliefert. Damit könnte man die Funktion 

map (zunächst eingeschränkt auf natürliche Zahlen) folgendermaßen definieren (die Sorte 

natlist wurde in 7.5.1. definiert): 

function map (nat → nat f, natlist lin): natlist 

return if isempty(lin) then empty else natlist(f(lin.head), map(f, lin.rest)) fi 

Meist spielt es allerdings keine Rolle, welcher Sorte die Elemente der Liste lin angehören, 

solange nur die Funktion f darauf anwendbar ist. Wir müssen daher in der obigen Definition 

noch Sortenparameter einführen (siehe auch Abschnitt 7.6): 

function map ( → f, list lin): list 

return if isempty(lin) then empty else list(f(lin.head), map(f, lin.rest)) fi 

Die passenden Sorten für die Platzhalter bzw. werden bei der Anwendung von 

map dann automatisch richtig gewählt werden, wie das folgende Beispiel zeigt: 

Wir verwenden dabei eine vordefinierte Funktion ord: 

function ord (char zn): nat code 

return // Rückgabe der ASCII-Codenummer des Zeichens zn 

Damit setzt die Anwendung 

map (ord, [´A´, ´B´, ´C´, ´D´]) 

die Sorte auf char bzw. auf nat und liefert folgenden Wert zurück: 

[65, 66, 67, 68]. 

Funktionen, die (wie map) mit Hilfe von Sortenparametern definiert sind und daher auf verschiedene 

Sorten angewandt werden (und/oder auch verschiedene Sorten zurückliefern) können, 

heißen polymorph. 

Weitere Beispiele für Funktionen, die andere Funktionen als Parameterwerte übernehmen, 

sind: 

Beispiel 1 (Filterfunktion): 

Diese Funktion filtert aus einer Liste alle Elemente, die ein bestimmtes Prädikat (das ist eine 

Funktion mit booleschem Rückgabewert) erfüllen: 

function filter( → bool f, liste lin): liste



return if isempty(lin) 

then empty 

else if f(lin.head) 

then list(f(lin.head), filter(f, lin.rest)) 

else filter(f, lin.rest) 

fi 

fi 

z.B. kann man damit (unter Verwendung der in 7.7.4 definierten Funktion gerade) die geraden 

Zahlen aus einer beliebigen Liste von Zahlen extrahieren: 

filter(gerade, [1,2,3,4,5,6,7,8,9,10]) = [2,4,6,8,10] 

Beispiel 2 (Faltung): 

Diese Funktion verknüpft die Elemente einer Liste mit Hilfe eines zweistelligen Operators. 

Verwendet man als Operator z.B. die Addition, so liefert diese Funktion die Summe aller Elemente 

der Liste. Dabei muss neben der jeweiligen Operation (als zweistellige Funktion) und 

der Liste der Werte auch das neutrale Element der jeweiligen Operation (z.B. 0 bei Addition 

bzw. 1 bei Multiplikation) als Wert der leeren Liste übergeben werden: 

function fold((×) → f, neutral, list lin): 

return if isempty(lin.rest) 

then neutral 

else f(lin.head, fold(f, neutral, lin.rest)) 

fi 

Eine beispielhafte Anwendung (unter Verwendung einer Funktion mult(a,b) = a*b): 

fold(mult, 1, [1,2,3,4,5]) = 1*2*3*4*5 = 120 

Beispiel 3 (Differenzenquotient): 

Der Differenzenquotient (f(x + ∆x) – f(x))/∆x liefert für sehr kleine ∆x eine gute Näherung 

für die Ableitung f´(x) einer differenzierbaren Funktion f an der Stelle x. Er stellt auch die 

Basis für die Definition der Ableitungsfunktion dar (nach Grenzübergang ∆x → 0): 

function diffquot(real → real f, real x, deltax): real 

return (f(x + deltax) – f(x))/deltax 

7.8.2 Funktionen als Funktionswerte 

Damit haben wir geklärt, wie eine Funktion als Argument übernommen werden kann. In funktionalen 

Sprachen kann man meist auch Funktionen definieren, die andere Funktionen als 

Werte zurückliefern. Diese Erzeugung als Werte anderer Funktionen stellt neben der expliziten 

Definition eine weitere Möglichkeit dar, neue Funktionen einzuführen, die manchmal 

kompakter, übersichtlicher leichter verifizierbar oder einfach nur eleganter ist. 

Beispiele wären z.B. die Verkettungsfunktion, die zwei Funktionen zu einer dritten kombiniert 

oder die Integration bzw. Ableitung (Differentiation) von Funktionen. 

Lässt man Funktionen als Ausgabewerte zu, so ergibt sich daraus auch die Möglichkeit der 

Verkettung von Funktionalen, indem eine Funktion als Ausgabe eines Funktionals als Wert an



ein anderes Funktional übergeben wird. Ein Beispiel dafür wäre die Anwendung vom map auf 

die Verkettung zweier Funktionen. 

Im Wesentlichen kann man in funktionalen Programmiersprachen Funktionen als Ausgabewerte 

auf zwei verschiedene Arten erzeugen: 

1) durch Verwendung von vordefinierten Funktionaloperatoren oder 

2) durch partielle Anwendung einer Funktion auf einen Teil ihrer Argumente. 

Funktionaloperatoren sind Operatoren, die Funktionen als Argumente verwenden und/oder 

Funktionen als Werte zurückliefern, wie z.B. die Funktionskomposition (Hintereinanderausführung) 

zweier Funktionen f und g (z.B. in Haskell durch f.g symbolisiert) : 

function komp(→ f, → g): → 

return // Die Funktion, die für alle Werte x, für die g definiert ist, den Wert f(g(x)) liefert 

Damit kann man nun z.B. die n-fache Iteration einer Funktion (n-fache Komposition) definieren: 

function iter( → f, n): → 

return if n =1 then f else komp(f, (iter(f, n-1)) fi 

Beispiel (Zweierpotenz als iterierte Multiplikation mit 2): 

function verdopple (nat n): nat 

return 2*n 

function zweihoch(nat n): nat 

return iter(verdopple, n) 

Die zweite Möglichkeit zur Erzeugung von Funktionen als Werten ist die Anwendung einer 

erzeugenden Funktion auf lediglich einen Teil ihrer Argumente (partielle Anwendung). Ein 

Beispiel: 

Durch partielle Anwendung der Multiplikationsfunktion mult(a,b) auf den Wert 2 für das erste 

Argument kann man (alternativ zu obiger Definition) die Funktion verdopple erzeugen: 

function verdopple (nat n): nat 

return mult(2,n) 

In funktionalen Sprachen verwendet man in diesem Zusammenhang oft das Prinzip von Curry 

(zunächst am Beispiel einer zweistelligen Funktion auf der Sorte nat erklärt): 

Jede Funktion f: nat × nat → nat kann man als Funktion fC: nat → (nat → nat) auffassen: 

Anstatt über f(a,b) = c aus der Verknüpfung zweier Werte a,b einen dritten Wert c zu berechnen, 

kann man so über partielle Anwendung auf das erste Argument (für jeden seiner Werte) 

eine neue (einstellige) Funktion ga: nat → nat definieren: 

ga = fC(a) und ga(b) = (fC(a))(b) = f(a,b) 

Das Ergebnis der Anwendung von f auf den Wert a ist also eine neue einstellige Funktion ga, 

deren Wert für das Argument b identisch mit dem Wert von f(a,b) ist.



fC heiß curried Version von f, umgekehrt heißt f uncurried Version von fC 

Dieses Prinzip wurde (wie übrigens auch die Sprache Haskell) nach dem amerikanischen Logiker 

Haskell B. Curry (1900–1982) benannt, obwohl es eigentlich zuerst vom deutschen Mathematiker 

M. Schönfinkel 1924 vorgeschlagen wurde. „Schönfinkeln“ klingt wohl etwas 

seltsam. 

Anstatt fC: nat → (nat → nat) schreibt man auch kurz fC: nat → nat → nat 

Der Vollständigkeit halber sei hier noch das Prinzip von Curry für eine beliebige Anzahl von 

Argumenten formuliert: 

Jede Funktion 

f: × × ... → lässt sich auch als curried Version darstellen: 

fC: → → ... → . 

Damit kann man jede Funktion auf eine Funktion mit höchstens einem Argument reduzieren 

und die Klammer bei der Anwendung daher immer weglassen: 

Statt 

f(a1, a2, a3, .., an) 

schreibt man in der curried Version 

fC a1 a2 a3 .. an 

und meint damit die Anwendung der Funktion, die sich aus der partiellen Anwendung von f 

auf a1, a2, a3, .., an-1 ergibt, auf an . 

Diese Sichtweise erlaubt nun sehr leicht die partielle Anwendung, wie in folgenden Beispielen: 

1) Multiplikation mit 2 (verdopple) entsteht durch Currying der normalen zweistelligen Multiplikation 

mult: nat × nat → nat mult(a,b) = c (unsere Ausgangsfunktion f) 

multC: nat → nat → nat mult a b = c (curried Version fC) 

verdopple: nat → nat verdopple b = mult 2 b 

2) Die Nachfolgerfunktion succ(n) kann durch partielle Anwendung der Addition add(a,b) auf 

das erste Argument dargestellt werden: 

add: nat × nat → nat add(a,b) = c (unsere Ausgangsfunktion f) 

addC: nat → nat → nat add a b = c (curried Version fC) 

succ: nat → nat succ b = add 1 b

7 Funktionaler Programmierstil und Rekursion (2. Teil) 7.7 Formen ...

Erfolgreiche ePaper selbst erstellen

Template löschen?

Als Template speichern?