Joshua wrote:
> Bookmarked, ’cause I want to know how you use array to get closures in Java (come back, Foo, come back!). Not that I actually write in Java hardly ever, but still.

Answer: Java’s anonymous functions are *almost* closures. Specifically, when you build an anonymous function within a block, it’s closed to all final local variables declared in that block or in an outer block.

The problem is that those variables *must* be final. Why? Who knows? There’s no performance hit unless you actually use a non-final variable, and even that’s not a very big hit. But Sun sought to screw us over I guess.

Well, almost. The array trick is as follows. Let’s say I wanted to make an accumulator generator (Paul Graham style, albeit with methods). I can do this:

interface NextInt { public int next(); }

public void makeNextInt(int init)
{
final int[] count = { init };
return new NextInt() { public int next() { return ++count[0]; }
}

Note that the NextInt class uses an outer lexical variable (count), and thus that variable must be final. But it doesn’t mean you can’t change it — it just has to be composite. Instead of having it be an int, make it be an int[1]. That’s the array trick.

Of course, you can make a MutableInteger or whatever if you want, and that’s a little faster as it doesn’t require an array bounds check, but it’s more work to write. It’s not part of the syntax of the language like the array is.

It turns out that there was a strong counterproposal to the crap being put out right now for excessively complex closure semantics. The counterproposal just does a simple semantic wrapper around exactly this idea. Let’s hope the Java folks get a clue and adopt it.

RenoX asked:

> Well Foo as the author has shown, D has anonymous function so you can use them for GUIs, are closure really necessary for GUIs?

Closures are hardly a necessary feature. But they are an *enormously* valuable feature for GUIs, threading, event management, and exception handling. Because they make doing callbacks elegant. Having anonymous functions without having closures based on lack of “need” is like saying you can do everything in recursion, so why bother with including for-loops…

Alex

FeepingCreature: Three interesting ways to fake closures, thanks for the tip.

Daniel: Your stack-copying writeup is really cool, I had no idea it could be that simple.

Joshua: You have several good points in your comments (and no bad ones ).

To be honest, it’s fairly rare that I come across a case where I miss being able to just directly return an inner function; and in cases where I want to do so, D has a few ways of working around that (both the hack in my post above, and also ones involving constructs like bind).

Here the code from Jarrett Billingsley for the multi-cast delegates:
>>
struct MCD(Args…)
{
void function(Args)[] funcs;

void opCatAssign(void function(Args) f)
{
funcs ~= f;
}

void opCall(Args args)
{
foreach(f; funcs)
f(args);
}
}

void fa(int x)
{
Stdout.formatln(”fa({})”, x);
}

void fb(int x)
{
Stdout.formatln(”fb({})”, x);
}

void main()
{
MCD!(int) a;
a ~= &fa;
a ~= &fb;
a(3);
}

Point being, there’s lots of ways to get close to real closures in D

Hans-Eric, I don’t think it’s even really a closure (or it wouldn’t matter if it were not) if it doesn’t use variables that have gone out of scope. And closure is incredibly useful for GUI code. E.g., (in browser JavaScript) half the time you use setTimeout. How many times have you seen someone assemble a string to pass as the first argument of setTimeout, potentially with escaping required and always making the later function query the DOM again to get back to the right element(s)? Passing a string invokes eval, which is asking for trouble, and the whole thing is a mess maintenance- and clarity-wise. Trivially solved with a real closure (as JavaScript can do, but many people don’t realize).

I don’t know what to be more astonished by: the fact that a *new* programming language doesn’t have a basic, incredibly useful feature like closures (and it’s *incredibly* useful for GUI work — it lets me easily construct anonymous functions to add as hooks for things like button presses etc.) or the fact that in this day and age there’s someone who actually thinks that closures aren’t a big deal except for functional languages.

The languages where I use closures the *most* are:

- Python
- Java (using the array trick)
- JavaScript

None of these languages is functional. In all of them, closures are incredibly useful. I can forgive ObjC for not having closures — it’s a language from the ’80s — but D? No way in hell.