self functions

Isiah Meadows impinball at
Tue Jul 28 19:29:46 UTC 2015

+1 for the decorator/function solution. It hardly affects performance in
practice, since the resulting wrapped function is a whopping two lines by
itself, and engines can optimize that very easily and efficiently. I don't
think there needs to be new syntax for it.

One thing I like about JavaScript: its flexibility. I'd say that after ES7
or ES8, there won't be a ton of reason for syntactic additions.

 From: Jussi Kalliokoski <jussi.kalliokoski at>
To: Bucaran <jbucaran at>
Cc: "es-discuss at >> es-discuss" <es-discuss at>
Date: Tue, 28 Jul 2015 09:43:58 +0300
Subject: Re: self functions

For classes, you can use decorators [1][1], if they eventually get in in
the language (just one extra symbol):

function self (object, name, descriptor) {
  var original = descriptor.value;
  return {
    value (...args) {
      original.apply(this, args);
      return this;

class Foo {
  constructor () {
    this.x = 0;

  method () {

console.log(new Foo().method().x) // 1

for ES5 style "classes", you can just use functions (2 extra symbols):

function self (original) {
  return function (...args) {
    original.apply(this, args);
    return this;

function Foo () {
  this.x = 0;

Foo.prototype.method = self(function () {

console.log(new Foo().method().x) // 1


On Tue, Jul 28, 2015 at 5:06 AM, Bucaran <jbucaran at> wrote:

Add a `self` decorator to functions that makes them return `this` by

                export function self myMethod () {
                        // return this by default

This decorator could be used to make any function bound to the current
scope `this` as well so:

                func(function self () { // this is bound to my dad’s scope

Would be roughly equivalent to:

                func(() => { // this is bound to my dad’s scope })

Although I personally would favor the arrow function syntax, the `self`
decorator could be
used to optimize binding generators, so instead of:

                func(function* () { }.bind(this))

One could write:

                func(function self* () { })

Similary it could be used in promise handlers, so instead of:

                new Promise(function (resolve, reject) { }.bind(this))

One could write:

                new Promise(function self (resolve, reject) { })

It would be even sweeter if you didn’t need to specify the keyword function
when writing `self` functions:

                new Promise(self (resolve, reject) { })
es-discuss mailing list
es-discuss at
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <>

More information about the es-discuss mailing list