Re: new Java lambda syntax
On Tue, 13 Sep 2011, Daniele Futtorovic wrote:
On 13/09/2011 04:24, Joshua Cranmer allegedly wrote:
On 9/12/2011 7:00 PM, Daniele Futtorovic wrote:
On 12/09/2011 00:07, Joshua Cranmer allegedly wrote:
List<Runnable> runners = new LinkedList<Runnable>();
for (int i = 0; i< 10; i++) {
runners.add(() => { System.out.println("Value of i is " + i); });
}
for (Runnable r : runners) {
r.run();
}
Beg your pardon, I haven't followed this issue as closely as I
probably have should, but does this all mean lambdas are always
Runnables? Never Callable<T>s? IOW, no return values?
No, I just opted for Runnable here because it was simple.
Okay, so you can have a lambda returning a value? Steve Simpson's statement:
There's no (...) long jumps (break, continue, return, throw)
seemed to contradict that, as did Tom's about the "Gafterist nonsense"
(<3), seeing how Gafter et al.'s proposal contained return values, IIRC.
Brachaism-Gafterism is the CANCER THAT IS KILLING JAVA!!
I mean, if they cannot return values, I'm a bit at a loss understanding
how they'll be the nec plus ultra for parallel computing... you'd
publish results to a shared queue, I suppose, but that's a bit unhandy.
A lambda can return a value. It just can't return it from another method.
You will be able to say (something like):
Callable<String> one = () => {return "uno";};
String s = one.call();
assert s.equals("uno");
You will not be able to say:
String thisIsWhatBGGAWanted() {
Callable<String> one = () => {return "uno";};
one.call();
return "ein";
}
String s = thisIsWhatBGGAWanted();
assert s.equals("uno");
Basically, lambdas can be either method-like (they return values from
themselves) or statement-like (they return values from their enclosing
methods). Lambdas are method-like in all the current dynamic languages
(AFAIK - they certainly are in Smalltalk, Python and Javascript). The BGGA
proposal (and i remember this coming from Gafter in particular, BICBW)
would have made them statement-like.
The rationale was that enclosing any given wodge of code in a lambda
definition immediately followed by an invocation of that lambda would not
change the behaviour of the code. This seemed dubious to me, and would
have led to very weird programming experiences. It would, though, have
enabled a wider range of funky control structures implemented on top of
lambdas, which some people are very keen on.
tom
--
Oh well, one plays these games and the scones did look rather
delicious. -- Stephen Fry