(Oops, forgot to reply all, so repost)
But the syntax you propose is redundant, since you can define a own() method
returning an iterator (for for...in) and a getOwn() method to do the same
thing. Or, if you think getOwn() is ugly, you can customize the own() method
to also return a view object:
// Defined in some library (possibly builtin)
class OwnPropertiesEnumerator {
val obj;
val iter;
OwnPropertiesEnumerator(obj) {
this.obj = obj;
this.iter = obj.iterator::get();
}
function next() {
return iter.next();
}
meta function get(name) {
if (obj.hasOwnProperty(name))
if (obj[name] is Function) {
// make sure |this| in a method doesn't refer to an instance
of this class
return function(...args) {
if (this is OwnPropertiesEnumerator)
return obj[name].apply(this.obj, args);
return obj[name].apply(this, args);
}
}
return obj[name];
}
meta function set(name, value) {
obj[name] = value;
}
meta function has(name) {
return obj.hasOwnProperty(name);
}
meta function delete(name) {
if (obj.hasOwnProperty(name))
delete obj[name];
}
}
Object.prototype.own = function() {
return new OwnPropertiesEnumerator(this);
}
Object.prototype.propertyIsEnumerable(own, false);
...
// User code
print(foo.own().bar);
for (var prop in foo.own())
print(prop + : + foo[prop]);
Or something like that. I'm not completely familiar with ES4 syntax and what
has changed in the past months (using the Oct 07 overview pdf as a
reference), so the above may not be strictly correct, but you should get the
intent :)
-Yuh-Ruey Chen
On Sun, Aug 10, 2008 at 5:52 PM, Ingvar von Schoultz
[EMAIL PROTECTED]wrote:
YR Chen wrote:
There's no separate namespace for enumerable properties.
This is about something else, something that's come up several
times in the discussion archives. See for example this post:
https://mail.mozilla.org/pipermail/es4-discuss/2007-March/000578.html
Also, let's not add syntax for things that can easily be done with
functions.
Several syntaxes have been discussed. It seems to me that this
syntax would solve several problems that were discussed, and is
simple in implementation, very flexible and nicely readable.
Whether people still feel a need for a syntax, I don't know.
Ingvar
YR Chen wrote:
There's no separate namespace for enumerable properties. They are
properties with a hidden enumerable flag set. With that said, in ES4, only
non-fixed properties in the public namespace will be enumerable by default.
That means that properties defined in classes will not be enumerable unless
prefixed with |prototype|, and only custom properties defined in the
public namespace (which is the default namespace) are enumerable. So if you
don't want a property to be enumerable, just define it in another namespace
and also open that namespace (via |use namespace|). Or you can toggle the
enumerable flag off via some new method whose name escapes me.
Also, let's not add syntax for things that can easily be done with
functions. You can create your own iterator functions and use them, e.g.:
// assuming pythonic generators are in ES4 (there's an equivalent, albeit
uglier, non-generator way)
myDictClass.prototype.own = function() {
for (var x in this.iterator::get()) {
if (this.hasOwnProperty(x))
yield x;
}
}
for (var x in myDict.own()) ...
-Yuh-Ruey Chen
On Fri, Aug 8, 2008 at 1:07 PM, Ingvar von Schoultz [EMAIL
PROTECTED]mailto:
[EMAIL PROTECTED] wrote:
I think this would be useful:
Get an enumerable property:
var x = myDict [*enumerable] .someName;
var x = myDict [*enumerable] [someVariable];
Call the non-enumerable .toString():
var x = myDict [*!enumerable] .toString();
Distinguish between owned and inherited properties:
var x = myDict [*own] .someName;
var x = myDict [*!own] .toString();
Loop through a subset:
for (var x in myDict [*own]) {...}
The syntax is meant to suggest that we pick a subset, such as
all the enumerable properties, and then pick a property from
this subset.
Here's an alternate syntax, more logical but less readable
in my opinion:
var x = myDict .:enumerable .someName;
var x = myDict .!enumerable .toString();
--
Ingvar von Schoultz
___
Es4-discuss mailing list
Es4-discuss@mozilla.org mailto:Es4-discuss@mozilla.org
https://mail.mozilla.org/listinfo/es4-discuss
--
Ingvar von Schoultz
--- (My unusual use of capitals in code comes from my opinion that
reserved and predefined words should all start with lowercase, and
user-defined should all start with uppercase, because this
