Q:

Readability for class method as callback: with .bind or wrap in an arrow function?

Lets say I want to assign a class method as a callback, which is better? By better, I really mean for style & readability.
const Foo = class {
  /** @param {!Promise} */
  optionOne(theirPromise) {
    theirPromise(this.myHandler_.bind(this));
  }
  /** @param {!Promise} */
  optionTwo(theirPromise) {
    theirPromise(() => this.myHandler_());
  }
  /** @private */
  myHandler_() {
    // Do something classy
  }
};

I read the arrow function call as cleaner in this case, but if there are a bunch of parameters in the callback, it starts to get silly:
addCallback((a, b, c, d, e, f) => this.myHandler_(a, b, c, d, e, f))

I see the penalty of wrapping in a function, memory mostly, assuming the compiler doesn't trim the call away.

A:

Style and readability are subjective.
The arrow function could be considered a better practice since the parameters and arguments are explicit (more important if the method declaration is far away). bind could be considered more maintainable, as you don't need to touch it when adding/removing parameters. However, you can achieve the same with an arrow function and rest/spread syntax:
theirPromise((...args) => this.myHandler_(...args));

Now the only difference is bind being shorter, creating a function with correct .length, evaluating the this.myHandler_/this references immediately and some other peanuts.

