Syntax Proposal: Anonymous Arguments

doodad-js Admin doodadjs at
Fri Sep 23 21:20:45 UTC 2016

Should not “private fields” be a decorator ?


From: Jordan Harband [mailto:ljharb at] 
Sent: Friday, September 23, 2016 4:32 PM
To: Kenneth Powers <ken at>
Cc: es-discuss <es-discuss at>
Subject: Re: Syntax Proposal: Anonymous Arguments


@ is currently reserved for decorators, # currently for private fields. There aren't a lot of compelling syntax options left, to be sure.


On Fri, Sep 23, 2016 at 11:35 AM, Kenneth Powers <ken at <mailto:ken at> > wrote:

What proposal is "@" reserved for, by chance? I was trying to pick something that both wasn't used and can't be the name of a variable (e.g., underscore). I saw another proposal for "?" for partially applying functions, but that would be potentially ambiguous with the ternary operator.


As for resolving ambiguity, why not just do what Scala does <> ? It would seem to me that nesting these functions would be a sign you need to refactor anyway. 


As far as meriting its own syntax, that's why I referenced another language where the implementors found that it did merit its own syntax (though the underscore in Scala also does a lot more).


On Fri, Sep 23, 2016 at 2:00 PM, Jordan Harband <ljharb at <mailto:ljharb at> > wrote:

In Scala, the ambiguity of the underscore causes lots of confusion when you have nested functions - how is that handled in your proposal?


Bear in mind, I think it's a tough argument that `@ + 1` is so much better than `n => n + 1` that it warrants its own syntax.


Separately, the "@" is reserved for an existing proposal, so you'd have to come up with different syntax anyways.


On Fri, Sep 23, 2016 at 10:38 AM, Kenneth Powers <ken at <mailto:ken at> > wrote:

I have a proposal for new syntax in ES inspired by the placeholder syntax in Scala Functions <> .


Essentially, the idea would be to allow anonymous arguments. The most simple example would be a function which takes one argument (as far as the programmer is concerned):


    [1, 2, 3].map(@ + 1)


This would be the same thing as:


    [1, 2, 3].map(n => n + 1)


Just like in Scala, an anonymous function is created. This concept can be further extended in ES:


    [1, 2, 3].reduce(@0 + @1, 0)


Which would be the same thing as:


   [1, 2, 3].reduce((sum, n) => sum + n, 0)




es-discuss mailing list
es-discuss at <mailto:es-discuss at>




-------------- next part --------------
An HTML attachment was scrubbed...
URL: <>

More information about the es-discuss mailing list