Native Proxy Syntax

# Vihan Bhargava (a year ago)

The Proxy class is great for classes however at the moment, the current syntax can be unwieldy:

class MyClass {
   constructor() {
       return new Proxy(this, {
           get: function(target, name) {
               if (name in target) return target[name];
               // ... do something to determine property
           }
       });
   }
}

My proposal is to introduce a more idiomatic syntax for proxies in classes:

class MyClass {
   constructor () { ... }
   get *(name) {
       // ... do something to determine property
   }
}

This already is much more clear than the above.

# Matthew Robb (a year ago)

I feel like this would be easier handled as a subclass helper:

f
​unction asProxy(traps={}, Class=function asProxy(){}) {
  return class extends Class {
    constructor() {
       super(...arguments);
       return new Proxy(this, traps);
    }
  }
}​

class MyClass extends asProxy({ ... }) { ... }

class MyOtherClass extends asProxy({ ... }, MyClass) { ... }
  • Matthew Robb
# Alex Kodat (a year ago)

It would seem that a more general solution would be to allow let inside a class definition and have the constructor close over the variables declared in the class:

class MyClass { let get = (target, name) => { if (name in target) return target[name]; // ... do something to determine property } constructor() { return new Proxy(this, {get}); } }


While this does require an extra return statement it's reasonably tidy and
has the huge benefit of providing private variables in a class (as local
variables in a closure). But I have to believe that this has been discussed
ad nauseum and there's probably a very good reason let (or some equivalent)
was not part of class.
# Rick Waldron (a year ago)

Inline...

On Wed, Aug 23, 2017 at 11:08 AM Vihan Bhargava <contact at vihan.org> wrote:

The Proxy class is great for classes however at the moment, the current syntax can be unwieldy:

class MyClass {
   constructor() {
       return new Proxy(this, {
           get: function(target, name) {
               if (name in target) return target[name];
               // ... do something to determine property
           }
       });
   }
}

My proposal is to introduce a more idiomatic syntax for proxies in classes:

class MyClass {
   constructor () { ... }
   get *(name) {
       // ... do something to determine property
   }
}

This looks too much like GeneratorMethod syntax:

class Foo {
  constructor() {}
  * gen() {}
}