Lambda-Notation; Funktionsprozeduren

Wollen wir eine Funktion durch einen Rechenterm definieren, der von mehreren Veränderlichen abhängt, so müssen wir kenntlich machen, welche der Veränderlichen bei der Anwendung durch das Argument zu ersetzen ist; die anderen Veränderlichen bleiben frei.

Beispiel: gegeben sei der Term x*x + y*y. Damit können wir zwei verschiedene  Funktionen bilden:

x f1(x) = x*x + y*y, f1(a) = a*a + y*y
aber auch
y f2(y) = x*x + y*y, f2(a) = x*x + a*a
Dafür kann man auch schreiben:
f1 = x . (x*x + y*y), f2 = y . (x*x + y*y)
Der durch eine solche Lambda-Angabe gebundene  Bezeichner für den Parameter kann innerhalb seines Gültigkeitsbereichs (hier: die Funktionsdefinition) überall durch einen anderen Bezeichner ersetzt werden, solange dadurch keine Kollisionen entstehen; dadurch ändert sich die Bedeutung nicht.

In Programmiersprachen werden Funktionen durch Funktionsprozeduren vertreten, den Lambda-Angaben entspricht die Parameterliste.  In Modula 2 sind bei den Parametern und beim Ergebnis jeweils noch die Datentypen  anzugeben; damit sieht eine Funktionsvereinbarung beispielsweise für die Funktion f2 folgendermaßen aus: 

  PROCEDURE f2(y: REAL): REAL;
  BEGIN RETURN x*x + y*y
  END f2;
Sogar die Anwendung von Funktionen, die keinen Namen tragen, sondern die nur  durch einen Term gegeben sind, auf ein Argument läßt sich so anschreiben (zur Klarheit setzen wir Klammern):
(x . (x*x + y*y))(a) = a*a + y*y
Das ist dann interessant, wenn sich der Term selbst erst durch eine Berechnung ergibt, etwa die Bildung der Ableitung beim symbolischen Rechnen.

Es müssen übrigens nicht nur Veränderliche  sein, die durch eine Lambda-Angabe markiert und bei der Funktionsanwendung ersetzt werden; läßt man hier auch Funktionsbezeichner  zu, so kommt man zu den sogenannten höheren Funktionen; manche davon sind uns bereits wohlbekannt!

zurück | Inhalt | Index | vor | Vorlesung
Klaus Lagally, 22. Februar 2000, 19:36