When building classes in coffeescript, is there ever a reason to not use the fat arrow for the instance methods?

Question

When building classes in coffeescript, is there ever a reason to not use the fat arrow for instance methods?

Edit: Ok then! Great reply! :)

Answer 1

Let me add my alternative view.

The elaborate reasons expressed by @epidemian for avoiding fat arrow are well and good, but consider the following:

• if you don't care (much, or at all) about the "underlying prototype-based JS code" generated by CoffeeScript, insofar as you are able to write consistent and bug-free CoffeeScript code;
• if you don't plan to write a gazillion tiny classes ala Java, that will spend 99% of their time calling each other's methods up and down the inheritance tree and get little work done in the process; said another way, if you recognize that performance-sensitive "inner loops" are not a good place to put method calls;
• if you don't plan on decorating, monkey-patching, or otherwise modifying your classes' methods at runtime;
• if you state your usage of fat arrow in a header comment, for the benefit of future developers working on your code;

then I would recommend to always use fat arrow, as a habit, both for methods and for anonymous functions.

This will make your CoffeeScript code simpler, safer and more intuitive, because you will know that this and @ always refer to the current object whose method you are defining, as in most other programming languages, independently of whoever will be calling your functions and methods at runtime.

Stated more formally, fat arrow makes the this keyword (and its shorthand @) fully lexically scoped, like any other identifier. Programming language history shows that lexical scoping is the most intuitive and less error-prone way to scope identifiers. That's why it became the standard behaviour for all new languages a long time ago.

If you choose this path, thin arrow becomes the exception, and a useful one at that. You will use it to prepare those particular callbacks where you need this to refer to something defined at runtime by the caller, instead of your own object. This is a counter-intuitive meaning of this, but some JS libraries need this kind of behavior in user-supplied functions. The thin arrow will then serve to highlight those pieces of code. If I remember correctly, jQuery usually provides everything you need in the function arguments, so you can ignore its artificial this, but other libraries are not as benevolent.

NB: CoffeeScript 1.6.1 has a bug related to fat arrow methods, so you should avoid that. Previous and later versions should be ok.

Performance

When used as a regular (anonymous) function, fat arrow does not add any overhead. In method declarations it does add a tiny RAM and CPU overhead (really tiny: a few nanoseconds and a few bytes of RAM for each method call, and the latter disappears on engines with tail-call optimization.)

IMHO the language clarity and safety fat arrow gives in exchange is enough reason to tolerate and even welcome the small overhead. Many other CoffeeScript idioms add their own tiny overhead to the generated code (for loops, etc.) with the purpose of making the language behaviour more consistent and less error-prone. Fat arrow is no different.