Discuss
  • self functions

self functions

# Bucaran (9 years ago)

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

	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) { })
# Frankie Bagnardi (9 years ago)

Aside from returning this you're suggesting an alternate syntax for arrow functions? I don't see any value here.

More importantly, the syntax is ambiguous for unnamed functions.

// already valid syntax
var self = function self(){};
# Jussi Kalliokoski (9 years ago)

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

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

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

  @self
  method () {
    this.x++;
  }
}

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 () {
  this.x++;
});

console.log(new Foo().method().x) // 1
# Isiah Meadows (9 years ago)

+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 gmail.com>

To: Bucaran <jbucaran at me.com>

Cc: "es-discuss at mozilla.org >> es-discuss" <es-discuss at mozilla.org>

Date: Tue, 28 Jul 2015 09:43:58 +0300 Subject: Re: self functions

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

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

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

  @self
  method () {
    this.x++;
  }
}

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 () {
  this.x++;
});

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

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

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

            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) { })