Operators as Functions vs. this

[summivox]

o = a: 1, b: 2, f: -> <[a b]> .map (@.)
o.f!

currently compiles to:

var o;
o = {a: 1,b: 2, f: function(){
  return ['a', 'b'].map(function(it){
    return this[it];
  });
}};
o.f();

I believe a more useful semantics would be to implicitly bind this, as if I wrote:

o = a: 1, b: 2, f: -> <[a b]> .map ~> @[it]
o.f!

which compiles to:

var o;
o = {a: 1,b: 2, f: function(){
  var this$ = this;
  return ['a', 'b'].map(function(it){
    return this$[it];
  });
}};
o.f();

IIRC there are other situations where some expression has this implicit this binding semantics -- it felt so natural I forgot which ;)

[summivox]

Ah I recalled. A list comprehension has implicit this binding.

a = [this.f .. for arr] .filter g

compiles to:

var a;
a = (function(){
  var i$, x$, ref$, len$, results$ = [];
  for (i$ = 0, len$ = (ref$ = arr).length; i$ < len$; ++i$) {
    x$ = ref$[i$];
    results$.push(this.f(x$));
  }
  return results$;
}.call(this)).filter(g);

[vendethiel]

That's not really the same, because the closure we're generating is really an implementation detail.

[summivox]

That's really not the same

True.

Back on operators as functions: I can imagine code relying on unbound this, so a breaking change would likely be impossible. Alternatively, is it possible to have a bound version?

[vendethiel]

Let's move this to #634 :-).