yield syntax (diverging from: How would shallow generators compose with lambda?)
nmix at pandora.com
Sun May 17 19:00:40 PDT 2009
As a follow on to my argument I would cite two examples for why it
would be good to always require parenthesis when the send value is used:
Example 1 I saw somewhere else in this thread:
yield a ? b : c
(yield a) ? b : c | yield(a) ? b : c,
(yield a ? b : c) | yield(a ? b : c)
let x = yield-5;
let x = (yield) - 5; | let x = yield() - 5;
or is it
let x = (yield -5); | let x = yield(-5);
I know the rules for both examples are very clear, but programmers
don't always read the specs. :P To someone not intimately familiar
with JS order of precedence, either one presents ambiguity (or worse,
doesn't!) Why play with fire?
On May 17, 2009, at 8:39 PM, Neil Mix wrote:
> On May 17, 2009, at 7:01 PM, Brendan Eich wrote:
>> The mandatory parentheses could be avoided by breaking from
>> Python's precedent and making yield a canonical unary (that is,
>> high-)precedence operator like delete, !, etc. But then almost any
>> algebraic or logical expression computing the value to yield would
>> need parentheses, and people would make mistakes such as yield a +
>> b where they meant yield(a + b) -- as in Python -- but got yield(a)
>> + b.
> I'm going to make the argument that this is about where the
> parenthesis go -- not *if* -- but where.
> - we could always allow parenthesis to be dropped when the yield is
> the entire expression of an expression statement or the right-hand
> side of an assignment.
> - in my experience with JS 1.7 I almost always had to parenthesize
> the yield expression when it was in some other kind of expression.
> An in the cases where parenthesis weren't required, I parenthesized
> anyway to avoid ambiguity and maintain coding style consistency.
> (And because I got tired of predicting incorrectly whether or not
> parens would be required in a particular context.)
> So I would argue that there are two syntactical forms of yield,
> yield E and (yield E), and that the rules regarding the requirement
> for parenthesis are hard to predict (from personal experience).
> Therefore, I argue that it would make sense to simplify a bit:
> - the yield E form may be used when it is the entire expression of
> an expression statement
> - all other times it must be parenthesized
> Which is *kind of* a way of saying, if you're ignoring the send
> value, you don't have to parenthesize. But if you use the send
> value, you must parenthesize.
> And now that we've made clear the definition of parenthesized and
> non-parenthesized forms of yield, we can proceed to argue that
> yield(E) is a valid form of parenthesis, as much so as (yield E).
> Pros for yield(E):
> - backward compatible
> - easier to read (to my eye)
> - it "feels" more correct to me in context of the when-using-send-
> value rule
> Pros for (yield E):
> - consistent with python
> - doesn't present any is-it-a-function? ambiguities
> es-discuss mailing list
> es-discuss at mozilla.org
More information about the es-discuss