super, self, and sideways & durable vs. template

Bob Nystrom rnystrom at google.com
Mon Jun 13 10:38:29 PDT 2011


On Sun, Jun 12, 2011 at 2:17 PM, Brendan Eich <brendan at mozilla.com> wrote:

> But to use the prototypal pattern, you would want something that has been
> discussed a bit: class elements (class body elements) defining
> once-per-class-evaluation function, let, and const bindings not as
> properties, but as lexical bindings in the scope of the prototype methods
> and accessors.
>

I worry about treating a class body like a block scope and allowing variable
declarations inside it. The syntax is really close to declaring
*properties* inside
the class (which is mostly what classes are for) and I worry people will get
confused.

More so, if we allow that, it means a class body becomes "block-like". It'll
be a lexical scope and you'll be able to declare variables in it. At that
point, I fear people will start expecting *any* statement to work inside a
class body. Once we open that can of worms, it gets really hard to find open
syntactic space for the stuff we care about: being able to tersely declare
class, prototype, and instance members.

As much as possible, I'd like to have a class body be just a collection of
property definitions. I find that simpler to understand and less likely to
cause us to paint ourselves into some syntactic corner.

I've raised the issue among a couple of people and threads (although
> possibly not here on es-discuss) of whether the class syntax should rather
> avoid using declaration syntax to bind prototype properties. Declarations
> otherwise create lexical bindings.
>

Why not just declare them outside of the class?


> class Monster {
>  ...
>  function log(...rest) { /*...*/}
>
>  attack(target) {
>    log('The monster attacks ' + target);
>  }
> }
>

If it was me, I'd probably prefer to just do:

module DungeonCrawl {
  export class Monster {
    attack(target) {
      log('The monster attacks ' + target);
    }
  }

  function log(...rest) { /*...*/}
}

To me, modules are a nice clean way to say "here's what I expose, and here's
what I want to use just for myself."


> class Monster {
>  ...
>  function log(...rest) { /*...*/}
>
>  public log = log;
>
>  attack(target) {
>    log('The monster attacks ' + target);
>  }
> }
>

Oh man, that's confusing looking.


> Another avenue: even without a change to enable declarations in class
> bodies to bind once-per-class lexical bindings in the scope of the prototype
> methods, another alternative comes to mind: private prototype methods. With
> private name objects, these could be true properties of the prototype but
> not nameable outside of the class body's braced extent.
>

I really like this idea.

- bob
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.mozilla.org/pipermail/es-discuss/attachments/20110613/1e6879ba/attachment.html>


More information about the es-discuss mailing list