Brendan wrote:
> use private cachedHotness;
We have that kind of syntax reserved for pragmas:
I know, and that is why I threw it out there. To me, this kind of
messing around with the meaning of identifiers feels like a compile-time
thing, not a runtime thing... Allen's proposal treats "private" like
"var" and "const", and it makes me uneasy because it seems as if there
is something deeply non-parallel there. More below, but for now, I
withdraw the "use private" suggestion.
On 12/21/2010 07:33 PM, Allen Wirfs-Brock wrote:
My request to anyone who wants some sort of private object state access is:
propose the syntax you want to use.
Okay. I've read the strawman now, and I'm ready to make a sketchy proposal:
What we do currently for weak encapsulation (where currently weak means
advisory only) is prefix our identifiers with underscores. I would like
it if the private names syntax just made something like this work to
give us a stronger form of weak encapsulation. The strawman already
uses the # character, so let's stick with that. I propose that if you
prefix an identifier with #, you get a private name:
var counter = {
#count: 0;
next: function() { return this.#count++; }
reset: function() { this.#count = 0; }
};
This is just what we might write today, but with # instead of _.
In order for this to work you have to abandon the idea of scoped private
identifiers. I say: make all private identifiers scoped to the
compilation unit. Names wouldn't be private within a file or <script> or
eval'ed string, but they would be private across files. Given that this
encapsulation can be defeated with Object.getOwnPropertyNames anyway,
and given that programmers who really need within-file privacy can skip
this convenient syntax and create their own Name objects, I think this
ought to be good enough. (Though it does have important consequences
for script concatenation.)
The second part of my proposal is a little more shaky. The # token, by
itself, would evaluate to an opaque value such that:
o.#foo === o[# + "foo"]
This means that to share private names (all of them) across compilation
unit boundaries, you'd share the # value. (I'm not sure whether I'd
propose that Allen's #.foo syntax for converting just a single private
identifier to a Name object be retained or discarded.)
Note that this addresses the concern Oliver raised about accidentally
generating new private names on each invocation of a constructor. With
this proposal, #foo means the same thing everywhere and on every
invocation within a compilation unit.
Also note that the use of the # prefix removes the need for the whole
"Private Declarations Exist in a Parallel Environment" section of the
strawman.
David
_______________________________________________
es-discuss mailing list
es-discuss@mozilla.org
https://mail.mozilla.org/listinfo/es-discuss
