Support proposed ES Next "::" bind operator

[loucyx]

Edit from @DanielRosenwasser: Since this issue was filed, a separate proposal for :: was created called "extensions".

https://github.com/tc39/proposal-extensions

---

It will be great if TypeScript had an implementation of the "::" bind operator of ECMAScript 7. Some examples of this operator and the implementation in ES5:
Bind

// ES5
var log = console.log.bind(console);

// ES7
let log = ::console.log;

Call

// ES5
var forEach = Array.prototype.forEach,
    elements = document.querySelectorAll("div");

forEach.call(elements, div => { console.log(div); })

// ES7
let forEach = Array.prototype.forEach,
    elements = document.querySelectorAll("div");

elements::forEach(div => { console.log(div) });

[ref] [more examples]

[DanielRosenwasser]

I keep seeing this being called an ES7 operator. The strawman proposal has been up on the wiki for quite a while, but I don't see any proposal for it right now. I've tentatively marked this issue as ES7 anyway, but perhaps someone else can weigh in on this.

[kitsonk]

They implemented it in Babel but even they say it is highly experimental. While it might be a good idea, it is far away from being a standard and no runtime has implemented it.

[sebmck]

@DanielRosenwasser It was discussed at the March TC39 meeting (notes here). AFAIK it isn't being actively proposed as more feedback is required (The Babel implementation is a part of that feedback process).

[ivogabe]

I think this is the best way to implement extension methods (#9), since with this proposal the emit isn't based on type info.

Also this will (partially) solve #212 (bind, call & apply are untyped), since we can use the :: operator to bind methods:

// Bind
func.bind(obj);
obj::func;

// Call
func.call(obj, 42);
obj::func(42);

// Apply
func.apply(obj, arr);
obj::func(...arr);

We don't need bind, call and apply any more if we use the bind operator. The only missing feature of the bind operator would be currying, but I'm not sure whether that's used a lot. Personally I'm not using it.

Besides that, maybe we can emit a function expression instead of a bind call. Using bind() isn't good for performance and it isn't supported in ES3. I've written some code that could be generated. I've added temporary variables as the expression (console.log in this example) should be evaluated once I guess. My vote would be for the function expression / lambda approach.

// Source
foo = ::console.log;

// .bind (ES5, 6)
foo = (_a = console, _a.log.bind(_a));
var _a, _b;

// lambda (ES6)
foo = (_a = console, _b = _a.log, (...args) => _b.apply(_a, args));
var _a, _b;

// Function expression (ES3, 5)
foo = (_a = console, _b = _a.log, function() { _b.apply(_a, arguments); });
var _a, _b;

About function expression, I'm not sure whether .apply() accepts an ArrayLike, so we might need to wrap arguments inside Array.prototype.slice.call() to convert it to an array.

Since this feature is not standardized yet, we could add it first under an --experimentalBind flag.

[HerringtonDarkholme]

I personally think supporting a new feature without type safety is desirable. FYI, #1985

[filipstachura]

Here is more detailed description of the bind operator strawman:
https://github.com/zenparsing/es-function-bind

I must say that syntax proposed by Trine (https://github.com/jussi-kalliokoski/trine) looks way better than anything I saw before. I would love to write code in such functional form.

[rbuckton]

This feature would work well with an ability to specify the type of this in a function declaration (#229).

[Artazor]

@rbuckton are there any chances to parse the following syntax: #1985 (comment) ?

[RyanCavanaugh]

Our policy on ES7 features is to wait until they're in Stage 1. Someone should chime in here when that happens for this feature.