About private names

[Allen Wirfs-Brock]

On Mar 20, 2011, at 12:49 PM, Andrew Dupont wrote:

> OK, you lost me.
> 
> On Mar 20, 2011, at 2:36 PM, Allen Wirfs-Brock wrote:
> 
>> On Mar 20, 2011, at 10:55 AM, Andrew Dupont wrote:
>> 
>>> Right; I think Dean and I are saying that this would be the first time obj.foo meant something different from obj['foo']. And to ascertain that those two meant different things, I'd have to go searching through the code for a `private foo` declaration.
>> 
>> With the private name proposal obj.foo and obj.[#.foo] will always mean the same thing regardless of whether foo is scoped as a private name or as a regular property name.
> 
> I'm not comparing `obj.foo` and `obj[#.foo]`; I get that those two are equivalent for private names. (I don't know what you mean when you say those are the same for public names, though, because I don't know what `obj[#.foo]` means in a public context.)

From the Private Names Strawman:
The syntactic form is #. IdentifierName. This may be used as a PrimaryExpression and yields the property name value of the IdentifierName. This may be either a private name value or a string value, depending upon whether the expression is within the scope of a private declaration for that IdentifierName; 

> 
> 
>> BTW, if you know that a property name is foo, why would you ever code obj["foo"] instead of obj.foo?
> 
> The proposal strongly implies that the `private` declaration affects only "a property name on the right of . or the left of : in an object initialiser." Does it also affect bracket notation? In other words:
> 
> private foo;
> obj.foo = 42;
> obj['foo'] === obj.foo; // true or false?
> 
> If the answer is `false`, that's your answer for why I'd ever code `obj['foo']` instead of `obj.foo`. If the answer is `true`, then that answers one of the questions I was asking earlier; but it also means that there's no way to get around the fact that the `private` declaration is "shadowing" any possible use of a public property name called `foo` in the same lexical scope.

as Sam answered, the answer is false.

// test if a property name is a private name in the current scope:
if (#'foo==='foo') {
      //foo is bound when used as a property name  to its default string value, not a private name value
 } else {
     //foo has a private name binding
}


Yes, I appreciate that if private names existed you might use obj['foo'] to guarantee you were accessing a string-named property.  However, my  original comment was in response to your statement "It would mean a new  and _surprising_ distinction between dot notation and bracket notation."  I was trying to argue (apparently not very effectively) that there was already a significant distinction between dot notation and bracket notation and that private name is just building upon that distinction.  Without private names there is no particular reason to say obj['foo'] rather than obj.foo but there is a very important distinction between obj[foo] and obj.foo.  The private names proposal preserves that distinciton.

Allen
> 
> Cheers,
> Andrew

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.mozilla.org/pipermail/es-discuss/attachments/20110320/d746691a/attachment.html>