Should we do infix :: instead of private methods (and other things)?

[erights]

See tc39/proposal-pipeline-operator#107

[erights]

For :: to do the job of -> for hidden methods, we'd replace the hidden method declaration with a lexical function declaration as previously proposed. The first hidden method example at
https://github.com/zenparsing/js-classes-1.1#2-hidden-methods
becomes

class Spaceship {
  function flyTo(destination) {
    // Blast off!
  }

  flyToMoon() {
    this::flyTo(Location.MOON);
  }
}

[zenparsing]

@erights Using this approach, what would instance var references look like?

[bathos]

I rather like this — when I need private methods currently, I do exactly this but with .call() (and function declarations outside the body, obviously).

One q: if the syntax is function flyTo() {}, it suggests to me flyTo would be created with a [[construct]] slot and without a home object. What would actually occur?

[zenparsing]

if the syntax is function flyTo() {}, it suggests to me flyTo would be created with a [[construct]] slot and without a home object. What would actually occur?

Presumably, that's how it would work. That points to my main concern: that we would have two similar-but-different function definition forms inside of class bodies.

@erights I think I understand your concern: hidden methods are (more-or-less) just extension methods. But extension methods are useful generally, not just inside of class bodies. Shouldn't we try to think of a solution that works everywhere?

Is that what you're thinking?

🤔

[zenparsing]

@erights Just kicking some ideas around, purely for fun:

What if we had an extension declaration form:

'extension' '{' MethodDefinition* '}'

For example:

extension {
  x() {}
  get y() {}
}

This declaration form would introduce "hidden" bindings into the enclosing scope in a parallel namespace (similar to the way our current hidden methods work).

Using an extension accessor:

extension {
  get fullName() {
    return this.first + ' ' + this.last;
  }
}

({ first: 'Kevin', last: 'Smith' })::fullName; // 'Kevin Smith'

Extension declarations would also be allowed inside of classes:

class Person {
  constructor() {
    this.first = 'Kevin';
    this.last = 'Smith';
  }

  sayHello() {
    return `Hi, I'm ${ this::fullName }`;
  }

  extension {
    get fullName() {
      return this.first + ' ' + this.last;
    }
  }
}

Then I suppose that instance var references would be rationalized as automatically generated extension accessors within the class body.

I have no idea how you'd import and export these things, though 🙄

Again, just playing around for fun!