A closure is a just a piece of code with some context - data on which it works. Such things are common in the functional programming community but were left out of the C language because they're actually quite difficult to implement properly.
The C++ language has sufficiently powerful constructs that one can create closures, but the syntax is very unwieldy. One must write:
class Totalizer { int _total; public: Totalizer() : _total(0) { } void operator(int x) { _total += x; } int total() const { return _total; } }; int total(Vector<int> x) { Totalizer t; for_each(x.begin(), x.end(), t); return t.total(); } |
where one would really like to write something like:
int total(Vector<int> x) { int t; for_each (x, lambda(int y) {t += y;} ); return t; } |
Here the code is the "{t += y;}" bit and the context is the "t" variable, which is local to the "total" function.
C# 3.0 provides functionality like this.
What's really going on here is that an object is being created which encapulates some subset of the local variables (the "t" variable in this case) and which is passed to the for_each function (just like in the C++ version). Closures and objects are really just different syntaxes for the same thing.
If we want to return a closure from a function we can do so, but we must then allocate the object in such a way that the "t" variable will still be valid when the function exits. This is where things get really fiddly. This is one of those things that is easier in a language with garbage collection (you can just allocate the closure on the heap and the GC will take care of cleaning it up when it's finished with) but with care I think it should be possible to do it in a non-GC language as well.