On 2011-12-28 18:15, deadalnix wrote:
Le 28/12/2011 13:54, bearophile a écrit :
Timon Gehr:
=> expr
should imo be a shorthand for
() => expr.
It saves some ((())(()))().
It saves few (), but zero argument lambdas aren't that common in my
functional-style code, and I think it decreases syntax uniformity and
code readability. So I think it's a bad idea.
On the other hand I think extending the applicability of this syntax
to free functions/methods (as in Scala and Ada2012) is a nice idea, to
shorten tiny functions/methods, that are common enough:
class C {
private int x;
int getX() => x;
}
That would be great ! Uniformity is something we should look for.
------------------------
Walter:
They expect to see it, or else they mark D as "not having lambdas"
and "not supporting functional programming".<
To me this sounds like a bit silly argument to base language design on.
In my opinion the most important reason for the introduction of this
anonymous function syntax is that it makes D functional-style code
(and generally code that uses lot of callbacks) less noisy, so it
makes it more easy to write and read.
Bye,
bearophile
Both argument are fallacy. Javascript is a successful language (even if
some design decisions are arguably very bad). It use a lot of callback,
and promote event drivent programming so this type of consrtruct is used
everywhere. In addition, in Javascript, code source size matters.
The syntax to do such a thing is more verbose in javascript. So
definitively, this is a nice syntax, but this isn't that ground
breaking, and this isn't even required for people to use this type of
constructs.
I use CoffeeScript (which compiles to JavaScript) and it has a lot nicer
lambda syntax.
foo = (arg) ->
arg()
foo ->
# lambda code here
--
/Jacob Carlborg
