Lexical this in CoffeeScript fat arrow class methods when extracted

Question

Problem Context
CoffeeScript’s fat arrow (=>) binds this to the lexical scope, mirroring ES6 arrow functions. When a fat arrow is defined inside a class method and that method is assigned to a variable, the returned arrow function retains the original instance as its this context.
If the method is later invoked with a different this (e.g., via call/apply or as a callback), the arrow’s this does not change, which can lead to unexpected results. This behavior is documented for arrow functions but not explicitly for class methods, leaving developers uncertain about the intended semantics when methods are detached from their class instance.
Unresolved Decision
Should the lexical binding of this in fat arrow methods that return functions be considered a feature or a source of confusion? Is there a documented policy for how extracted methods should behave, and are there recommended patterns to avoid surprising this values?
Specific Questions

Does CoffeeScript intentionally preserve the original instance’s this when a fat arrow method is detached, or is this an oversight?
Is there a way to modify the binding so that the returned arrow function respects a new this context?
Should the CoffeeScript documentation be updated to clarify this behavior for class methods?

Tasadduq Burney · Answer

Answer
Yes, CoffeeScript intentionally preserves the original lexical this when a fat arrow (=>) method is detached from its instance. Because fat arrows create functions with a lexical binding—mirroring ES6 arrow functions—the this value is captured at the moment of definition and cannot be changed by call, apply, or bind.
To modify the binding so that a method respects a new this context, you must use a thin arrow (->). Thin arrows create standard functions where this is determined by the call-site.

Confirmed Behavior

Immutable Binding: Once a fat arrow function is created, its this context is locked to the scope where it was defined.
  Extraction Persistence: Assigning a fat arrow method to a variable (extracting it) does not break this bond; the function continues to reference the original lexical scope.
  Rebinding Failure: Standard JavaScript methods used to change context (like Function.prototype.call) are ignored by arrow functions.

Version-Dependent Implementation
While the lexical behavior is consistent, the value of this depends on how the compiler handles the class definition:

CoffeeScript 1.x: Methods defined with => are typically emitted as instance properties assigned within the constructor. In this case, this is captured as the instance being constructed.
  CoffeeScript 2.x (ES2015 target): If compiled to ES6 classes, a fat arrow in a class body may capture the lexical scope of the class definition itself (often the module or global scope) rather than the instance. In strict mode, this may result in this being undefined.

Verification and Safe Testing
To verify which binding behavior your current environment uses, run the following test:
class Tester
  fat: => this
  thin: -> this

testInst = new Tester
fatFn = testInst.fat
thinFn = testInst.thin

console.log("Fat (Extracted):\", fatFn())
console.log("Thin (Extracted):", thinFn())

If fatFn() returns the instance but thinFn() returns undefined (or the global object), your compiler is assigning the fat arrow within the constructor.

To provide a specific architectural recommendation, please clarify your CoffeeScript version and whether you are targeting ES5 or ES2015 output.

Lexical this in CoffeeScript fat arrow class methods when extracted

Problem Context

Unresolved Decision

Specific Questions

1 answer

Answer

Confirmed Behavior

Version-Dependent Implementation

Verification and Safe Testing

Your perspective belongs here.

1 question comment