Lew said:
As so many on this thread have pointed out, Java can do what closures
do, you just have to think in terms of object-orientation and
polymorphism instead of interpreted, loosey-goosey self-rewriting code.
Having closures in a language is completely unrelated to being
interpreted, loosely typed, or otherwise "unproffessionel". Take a
language like Haskel, which has a very string, but also powerful, type
system. It's functional though, which is where closures typically
occour.
Many have argued for closures in Java. I am against them for the
moment, since there are already idioms that accomplish the same thing
without the conceptual mindtwist.
For someone used to programming in functional languages, the
conceptual mindtwist comes when you try to express a perfectly simple
anonymous function value as an object of some unnecessary class or
interface. It's just syntactic wrapping necessary to live in a language
where only objects (and primitives) are expressible and denotable objects.
The argument for closures isn't really about functionality, which
is there already, but about syntax. Just as enums were added to provide
simpler syntax for a commonly occuring programming construct, simpler
syntax could be provided for function values.
Simpler syntax, like for enums, provides nothing but readability. It
makes it easier to express the programmers intent and easier to
recognize it for a reader. The more unnecessary syntax is wrapped
around the essential idea, the less accessible it is.
What is easier to read:
myCollection.foreach(new Callable<Integer>() {
void call(Integer v) {
sum += v;
}
});
or
myCollection.foreach(fn(Integer v) { sum += v; });
Once again, that would be polymorphism, possibly with inner or
anonymous classes, combined with generics to provide compile-time
safety.
It's quite possible. It's just so ... wordy.
Java is a professional language, not a script-kiddie hack
language. Things like program invariants, compile-time safety and
maintainability carry weight here.
Which is why generics was a good addition (collections were untyped
before). And why syntactic sugar making often used idioms were made
easier to express: enums, iterations over iterables and arrays,
boxing and unboxing.
I happen to think that easier syntax for delegates, which is essentially
what is needed, would be great. Real closures capturing local variables
might not be necessary, but it would be nice.
/L
