Brendan Eich wrote:
That is coherent with "new Foo" - 'Foo is the class' means 'new Foo
returns new instance'.
Yes, but your first example, class List(n) {...} cited above at the very
top, uses .{ to add what looks like prototype methods at and size. If
class List(n){...} evaluates to the constructor then you're adding these
to the constructor function, not to its prototype. You'd need
class List (n) {
this.@arr = n === +n ? new Array(n) : [];
}.prototype.{
at (i) {
i = +i;
if (i>=0 && i<this.@arr.length) { return this.@arr[i]; }
else throw "Out of bounds: "+i;
}
size () { return this.@arr.length; }
}
And of course to make this work when used as an expression that should
evaluate to the constructor function, tack on a .constructor at the end.
Was this just a mistake or are you trying to have class List(n){...}
evaluate to the prototype while List later evaluates to the constructor?
I am still confused by what you wrote and believe it does not hang
together.
I am probably writing densely and you had little time. I have written at
the beginning of 1.:
'class ...}' as a sugar for 'function ...}.prototype'
(I put similar texts describing the idea to the header of 2. and 3. as well)
So, exactly, I wanted class List () { ... } work exactly the same as
function List () { ... }.prototype - so List is the function but
completion value is its prototype.
Which lets do the
class List (..) {
...
}.{
// instance methods here
}
which is the most used case, but needs
List.{
// static ones here
}
and is not exactly fine for class-expressions. But 1. is very minimal,
leaving hard cases to be harder, but since it is only slightly-modified
function (and user can by the time already learned enough to understand
that 'class' is just a sugar), user can very easily switch class keyword
to function keyword when it fits better for the situation. This 'class
as function except returning prototype' is really useful primarily for
declaring classes (and as a black magic for learners until they are
later told class is nothing special). Just hinting it as one alternative
of minimal 'class' use. Maybe it inspires something.
The other ones use 'class' differently.
And that takes us around the hermeneutic cycle again, which was my point
about classes not reaching consensus easily or by shotgunning the design
space. You may hit something but not bring down the prize bird: the
right not-too-minimal and not-too-maximal classes.
Maybe one of the alternatives (I like the 2. even when it needs do
expressions when you want full-fledged class expression) can strike a
chord with some of the readers.
1. is super-minimal (even when it returns the prototype) as its plus.
/be
_______________________________________________
es-discuss mailing list
es-discuss@mozilla.org
https://mail.mozilla.org/listinfo/es-discuss
