Expression closures - use-cases for shortcut lambda syntax(blocks)

Igor Bukanov igor at
Wed Mar 21 03:26:10 PDT 2007

On 21/03/07, Lars T Hansen <lth at> wrote:
> On 3/20/07, Brendan Eich <brendan at> wrote:
> > It's not just aesthetics. Aesthetics is the science of beauty, but
> > usability is what users grok -- not always what is beautiful. IOW,
> > the pile of "function" keywords in the Y combinator:
> >
> > function Y(le) {
> >      return function (f) {
> >          return f(f);
> >      }(function (f) {
> >          return le(function (x) {
> >              return f(f)(x);
> >          });
> >      });
> > }
> The Y combinator is not even remotely a compelling use case  for
> ECMAScript.  ;-)  More compelling are those that have already been
> posted in this thread, and as I wrote before, I didn't find those very
> compelling either.

Yet Y combinator is a useful boundary case to test syntax proposals
that in fact caused me to cool for the proposal. Here are the

function(le) (function(f) f(f))(function(f) le(function(x) f(f)(x)))

le => (f => f(f))(f => le(x => f(f)(x)))

Both are better then the original version and it seems that "name =>
expr" is significantly less clattered than the "function (name) exp"
case. But I remember when I saw for the first time Y code written in
Haskell (which is much more suited to write that kind stuff) then to
grasp the idea I had to rewrite it using:

function selfApply(f) f(f)

which gives for the combinator:

function(le) selfApply(function(f) le(function(x) f(f)(x)))

le => selfApply(f => le(x => f(f)(x)))

Now the "=>" case does not look that much better and in fact I suspect
that to comprehend the code it can be worse than using function
keyword since an explicit and long keyword gives a useful reference

The bottom line: "=>" allows to create incomprehensible but nicely
looking code yet for simpler down-to earth cases its advantages are
minor if any.

Regards, Igor

More information about the Es4-discuss mailing list