http://www.artima.com/weblogs/viewpost.jsp?thread=202004

This comparison, hopefully, lets you choose which features are important to you and demonstrates that the proposals, other than CICE, are really a collection of features that includes new syntax for inner classes/closures.

class TestContinuation {
class Closure {
private Object state = null;
public Closure(Object state) {this.state = state;}
public Object call() {return state;}
}
public void continued(Closure continuation) {
continuation.call();
}
public void main (String[] args) {
continued(new Closure(null));
}
}

If you really need the convenience of a concise syntax and the dynamism of an interpreter, use something else than Java.

I suggest CPython but you can have your way with JRuby too

Or wait for Java 1.7, although that could be a long time …

Kind regards,

Pick up a book on functional programming (e.g. using Common Lisp) and find exercises there. There’s no need to cook up new ones.

final list = Collections.sort inList, method( str1, str2 ) {
__str1.length - str2.length
};

Contrast this with Java 5+:

final Collection list = Collections.sort( inList, new Comparable() {
__public int compare( final String str1, final String str2 ) {
____return str1.length() - str2.length();
__}
});

The essence of the C3S proposal is, as the name suggests, to provide Clear, Consistent, and Concise Syntax in that order of priority. In particular Clarity and Consistency are not sacrificed in the name of conciseness. Part of the consistency aspect is not only syntax that is familiar, in particular it uses un-abbreviated keywords, but also it builds upon features already in the language, e.g. inner classes, rather than adding new features, i.e. closures with subtly different semantics than inner classes.

I would be happy to code some of your examples in my proposal, but Java 5+ versions would be easier to work with than 4.

Please feel free to suggest practical problems that you feel might demonstrate the need for full closures as opposed to merely function pointers. They jey, though, is that they have to be phrased in terms of what we want to calculate/do rather than the algorith/technique by which we calculate/do that.

A lot of the examples I’ve seen essentially bake the answer straight into the question. They’re more of the form, “How do you drive a Ford Escort with standard transmission from Detroit to New York?” than “How do you travel from Detroit to New York?”

Currently, objects of (non-static) inner classes aren’t quite closures: they capture the values of local variables, but not the variables themselves, because an inner-class object can only see final variables, which can be copied freely since they cannot be mutated.

Examples that don’t exercise the power of capturing local variables (and it’s a power you probably don’t feel the lack of because you’ve never had it) aren’t really examples of closures at all; they are just syntactic sugar.

Also, three other ideas - (a) iterating around a map, with easy access to the key/value. (b) iterating around a collection and removing items that match some criteria. (c) Accessing a file, and ensuring it is closed afterwards.