The whole idea about having closures is just having a way to pass a Java block as a variable. We already do that using Runnable, but the whole point of Runnable is that it is an anonymous inner class and half the code you type is just boilerplate.

Can we remove the bolierplate?

If the answer is yes, then we don’t need to introduce new mechanisms into Java. That should be one of the deciding criteria.

The example should be about moving the block into a variable. Also you are not instantiating a class, but a block (which is finally a method, and it doesn’t matter if internally Java uses the anonymous inner class mechanism):

int compare( String, String ) = Comparator.compare( String s1, String s2 ) { return s1.length() - s2.length(); };
Collections.sort( ls compare );

It has better syntax, doesn’t it?

If the future of open source java is scratching everyone’s minor itch to “fix” the language, maybe it’s finally time to move on to python or ruby.

In CICE:
List ls = … ;
Collections.sort(
ls,
Comparator( String s1, String s2 ) { return s1.length() - s2.length(); }
);

In BGGA (I think - you need a closure conversion to make a closure into an instance of an interface - which I think is intended to be implicit):
List ls = … ;
Collections.sort(
ls,
{ String s1, String s2 => s1.length() - s2.length(); }
);

Note the use of => to separate arguments from body and that you can’t use return in this context, the value returned is implicitly the value of the last statement and if you add an explicit return it is an error.

In my C3S proposal:
declare ls = … ; // Note type inference from right hand side of equals sign
Collections.sort(
ls,
method( s1, s2 ) { return s1.length - s2.length }
);

I find this C3S more readable than current Java, CICE, and in particular BGGA. What do others think?

List ls = …
ls.sort(s1, s2) { return s1.length() - s2.length(); }

This is not only shorter, but it’s also much more intuitive.

The CICE one, after it’s properly indented. Nobody forces you to use the unindented version.

“all those silly rules about final local variables, this inside inner classes, and other arcana I can never quite remember…”

You do understand all those silly rules exist _because inner classes are not closures_, right? If Java had real closures, they would go away.

See http://gafter.blogspot.com/2007/01/definition-of-closures.html.