Closure
Ein Closure (oder Funktionsabschluss) ist eine Funktion, die Zugriff auf den Erstellungskontext einer anderen Funktion hat. Beim Aufruf greift die Funktion dann auf diesen Erstellungskontext zu, selbst wenn der Kontext außerhalb der Funktion nicht mehr existiert. Ein Closure ist somit ein Zugriff auf eine sonst nicht mehr vorhandene Speicherstruktur (closed term). Erreicht wird dies meist durch zwei verschachtelte Funktionen - die Hauptfunktion wird mit einer weiteren Funktion „abgeschlossen“, die auf den Erstellungskontext der Hauptfunktion zugreift und ihn damit erhält.
Inhaltsverzeichnis |
Herkunft [Bearbeiten]
Closures sind ein Konzept, das aus den funktionalen Programmiersprachen stammt, zum ersten Mal in LISP auftrat und in seinem Dialekt Scheme erstmals vollständig unterstützt wurde. Daraufhin wurde es auch in den meisten späteren funktionalen Programmiersprachen (etwa Haskell, Ocaml) unterstützt.
Vorteile und Eigenschaften [Bearbeiten]
Mit Closures können nicht sichtbare, aber kontrolliert veränderbare Bereiche erstellt werden, beispielsweise kann damit Datenkapselung realisiert oder Currying umgesetzt werden, wenn es dafür keine anderen Sprachkonstrukte gibt.
Implementierungen [Bearbeiten]
Es existieren auch nicht-funktionale Programmiersprachen, die diese Funktion unterstützen. Hier wären Ada[1], Object Pascal (Delphi)[2][3], JavaScript[4], Smalltalk, Python, Lua, Ruby, C#, Visual Basic (nur .NET), C++ (nur im Standard C++11), Groovy, Go, PHP und Perl zu nennen. Auch die objektorientierte Programmiersprache Java unterstützt eine limitierte Variante von Funktionsabschlüssen in Form anonymer und lokaler Klassen. Apple hat den gcc und Clang um Closures – genannt Block-Literals – für C erweitert und dies zur Standardisierung vorgeschlagen.[5]
Beispiele von Implementierungen [Bearbeiten]
Pseudocode [Bearbeiten]
Im folgenden Beispiel wird zunächst eine Funktion mutterfunktion definiert. Diese Funktion setzt eine lokale Variable namens kuchen und definiert eine lokale Funktion namens kindfunktion.
funktion mutterfunktion {
setze kuchen = 'Apfelkuchen'
funktion kindfunktion {
gib_aus 'Ich esse #{kuchen}'
}
gib_zurück kindfunktion
}
Bei einem Aufruf gibt sie die lokale Funktion kindfunktion zurück.
Die globale Variable kind bekommt also die Funktion kindfunktion zugewiesen, sodass beim anschließenden Aufruf von kind folglich kindfunktion ausgeführt wird. Obwohl keine globale Variable kuchen existiert, gibt kindfunktion die Zeichenkette 'Ich esse Apfelkuchen' aus, weil sie auf ihren Erstellungskontext zugreifen kann, in dem die Variable kuchen mit 'Apfelkuchen' definiert ist. Wichtig zu beachten: Obwohl mutterfunktion schon einen Wert zurückgegeben hat - der Kontext also eigentlich nicht mehr existiert - kann kindfunktion darauf zugreifen - kindfunktion ist also eine Closure-Funktion.
setze kind = rufe_auf mutterfunktion rufe_auf kind
Ich esse Apfelkuchen
Mit einer Änderung im Code wird nun die Variable in der mutterfunktion mit jeden Zugriff auf die Closure-Funktion der Wert um eins erhöht, womit sich ein Zähler realisieren lässt. Der Wert in anzahl_kuchen ist vor Manipulation geschützt und nur durch essen zu erhöhen.
funktion mutterfunktion {
setze anzahl_kuchen = 0
funktion kindfunktion {
setze anzahl_kuchen = anzahl_kuchen + 1
gib_aus 'Ich esse #{anzahl_kuchen} Kuchen'
}
gib_zurück kindfunktion
}
Durch Aufrufen kann auf einen sonst nicht sichtbaren Bereich zugegriffen werden und innerhalb der kindfunktion können Berechnungen mit sonst nicht veränderbaren Werten vorgenommen werden – das sind die wesentlichen Vorteile von Closures.
setze essen = rufe_auf mutterfunktion rufe_auf essen rufe_auf essen rufe_auf essen
Ich esse 1 Kuchen Ich esse 2 Kuchen Ich esse 3 Kuchen
Perl [Bearbeiten]
Der Kontext eines beliebigen Code-Fragments wird unter anderem durch die zur Verfügung stehenden Symbole bestimmt:
# pragma use strict; sub function { my ($var1, $var2) = @_; # Argumente in benannte Variablen kopieren # block code ... }
Im oben gezeigten Beispiel sind die Variablen $var1 und $var2 an jeder Stelle der Funktion gültig und sichtbar. Beim Verlassen der Funktion werden sie zusammen mit dem verlassenen Block aufgeräumt („gehen“ out of scope) und sind anschließend unbekannt. Jeder weitere Zugriff wäre ein Fehler.
Closures bieten nun die Möglichkeit, den Gültigkeitsbereich solcher Variablen über dessen offizielles Ende hinaus auszudehnen. Dazu wird im Scope einfach eine Funktion definiert, die die betreffenden Variablen verwendet:
# pragma use strict; sub function { my ($var1, $var2) = @_; return sub { print "Vars: $var1, $var2.\n" }; } my $f = function("Hallo", 8); my $g = function("bar", "Y"); # Aufruf von $f $f->(); # Aufruf von $g $g->();
Das Laufzeitsystem stellt jetzt beim Verlassen der Funktion function fest, dass noch Referenzen auf die Blockvariablen $var1 und $var2 bestehen – der Rückgabewert ist eine anonyme Subroutine, die ihrerseits Verweise auf die Blockvariablen enthält. $var1 und $var2 bleiben deshalb mit ihren aktuellen Werten erhalten. Weil die Funktion auf diese Weise die Variablen konserviert, wird sie zur Closure.
Mit anderen Worten kann man auch nach dem Verlassen des eigentlichen Gültigkeitsbereichs der Variablen jederzeit den Aufruf $f->() und den Aufruf $g->() ausführen und wird im Ergebnis immer wieder die bei der Definition der Funktionen gültigen Werte der Variablen angezeigt bekommen.
Dies ergibt die Ausgabe:
Vars: Hallo, 8. Vars: bar, Y.
Ändern kann man diese Werte nicht mehr, da die Variablen außerhalb der Closure nicht mehr verfügbar sind. Das liegt aber vor allem an der Funktionsdefinition: natürlich hätte die Closure die Werte nicht nur ausgeben, sondern auch bearbeiten oder auch aufrufendem Code wieder per Referenz zur Verfügung stellen können. In der folgenden Variante werden beispielsweise Funktionen zum Inkrementieren und Dekrementieren eingeführt:
# pragma use strict; # function sub function { my ($var1, $var2) = @_; return ( sub {print "Vars: $var1, $var2.\n"}, sub {$var1++; $var2++;}, sub {$var1--; $var2--;} ); } # call the function my ($printer, $incrementor, $decrementor) = function(3,5); # use closures $printer->(); $incrementor->(); $printer->(); $incrementor->(); $incrementor->(); $printer->();
Dies ergibt die Ausgabe:
Vars: 3, 5. Vars: 4, 6. Vars: 6, 8.
Closures lassen sich also beispielsweise dazu verwenden, den Zugriff auf sensible Daten zu kapseln.
Python [Bearbeiten]
Folgend ein einfaches Beispiel für einen Zähler in Python, der ohne einen (benannten) Container auskommt, der den aktuellen Zählerstand speichert.
def closure(): container = [0] def inc(): container[0] += 1 def get(): return container[0] return inc, get
Im Beispiel werden innerhalb der closure-Funktion zwei Funktionsobjekte erstellt, die beide die Liste container aus ihrem jeweils übergeordneten Scope referenzieren. Ist die closure-Funktion also abgearbeitet (nach einem Aufruf) und werden die beiden zurückgegebenen Funktionsobjekte weiter referenziert, dann existiert die container-Liste weiter, obwohl der Closure-Scope bereits verlassen wurde. Auf diese Weise wird also die Liste in einem anonymen Scope konserviert. Man kann nicht direkt auf die Liste container zugreifen. Werden die beiden Funktionsobjekte inc und get nicht mehr referenziert, verschwindet auch der Container.
Die Closure im vorigen Beispiel wird dann auf die folgende Weise verwendet:
>>> i, g = closure() >>> g() 0 >>> i() >>> i() >>> g() 2 >>> container Traceback (most recent call last): File "<stdin>", line 1, in ? NameError: name 'container' is not defined
OCaml [Bearbeiten]
OCaml erlaubt das in folgender Weise :
let counter, inc, reset = let n = ref 0 in (function () -> !n), (* counter *) (function () -> n:= !n + 1), (* incrementor *) (function () -> n:=0 ) (* reset *)
jetzt ist der Zähler wie folgt anwendbar :
# counter();; (* ergibt 0 *) # inc();; # counter();; (* ergibt 1 *) # inc();inc();inc();; # counter();; (* ergibt 4 *) # reset();; # counter();; (* ergibt 0 *) # n;; (* n ist gekapselt *) Unbound value n
Statt eines Integers können natürlich auf diese Weise beliebige Objekte oder Variablen beliebiger Typen gekapselt werden.
JavaScript [Bearbeiten]
In der Funktion f1 wird eine weitere Funktion f2 als Closure definiert;
var f1 = function () { // eine äußere Funktion f1 definieren ... var wert = 22; // ... und darin einen Namensraum erstellen. var f2 = function () { // eine innere Funktion definieren, ... return wert; // ... die den Namensraum nach außen reicht. } return f2; // f2 durch f1 zurückgeben, womit f2 zum closure wird. } var a = f1(); // a ist die von f1() zurückgegebene closure-Funktion, ... document.write(f1() +"<br />"); // ... also: function() {return wert;} document.write(typeof wert +"<br />"); // ist undefined document.write(a()+"<br />"); // ergibt 22 document.write(f1()() +"<br />"); // ergibt 22, f2() ist hier aber nicht abrufbar
Obiges Beispiel etwas anders formuliert, die innere Funktion wird jetzt direkt aufgerufen:
var f3 = function () { var wert = 23; return function () { // die Funktion f3 gibt gleich die closure-Funktion zurück! return wert; }; } var b = f3(); // b ist wieder die von f3() zurückgegebene Funktion ... document.write(b()+"<br />"); // ... und liefert jetzt als Ergebnis 23 document.write(b+"<br />"); // b bleibt aber weiterhin ein Funktionsaufruf! document.write(f3()() +"<br />"); // liefert ebenfalls 23
Die eingebettete Funktion dient jeweils als Lieferant des in der übergeordneten Funktion definierten Wertes.
Die übergeordnete Funktion kann auch als anonyme Funktion definiert werden:
var wert = 24; var c = (function() { // die äußere als anonyme Funktion und ... return wert; // ... darin die innere Funktion definieren. }()); // die Funktion jetzt noch mit (); aufrufen. document.write(c+"<br />"); // ergibt 24
Die Closure kann auch mit einer Konstruktorfunktion erzeugt werden:
var d = (new Function("return wert;"))(); // mit einem Konstruktur definieren und aufrufen
Lua [Bearbeiten]
Lua hat eine eingebaute, und im Sinne der Programmierung auch intuitiv nutzbare Unterstützung für Closures, dessen Implementierung ähnlich zu der in Python ist:
function adder(x) -- Funktionserzeuger return function(y) -- anonyme, zu adder private Funktion return x+y -- x stammt hier aus dem äußeren Kontext end end
Eine Beispielnutzung sähe so aus:
add2 = adder(2) -- hier wird die Closure erzeugt print(add2(10)) --> Ausgabe 12 print(add2(-2)) --> Ausgabe 0
Eine Closure-Implementierung in Lua ist in [6] beschrieben.
Erlang [Bearbeiten]
Erlang als funktionale Sprache besitzt ebenfalls Closures, die allerdings Funs (Singular Fun, von function) genannt werden.
do_something(Fun) -> Fun(4). main() -> Var = 37, F = fun(N) -> Var + N end. Result = do_something(F). % Result =:= 41 =:= 37 + 4
Literatur [Bearbeiten]
- Ralf H. Güting, Martin Erwig, Übersetzerbau, Springer (1999), ISBN 3-540-65389-9
- Damian Conway, Object Oriented Perl
Einzelnachweise [Bearbeiten]
- ↑ John Barnes: Rationale for Ada 2005
- ↑ Craig Stuntz: Understanding Anonymous Methods
- ↑ Barry Kelly: Tiburon: fun with generics and anonymous methods
- ↑ Closures in Javascript (englisch)
- ↑ N1370: Apple’s Extensions to C (PDF; 69 kB)
- ↑ The implementation of Lua 5.0
