Map an array of functions to their return values in point-free style Introduction

I have some JavaScript code that uses Array.prototype.map to map an array of functions fns to their return values:



const fns = [() =&gt; 1, () =&gt; 2];
const result = fns.map(
  fn =&gt; fn()
);
console.log(result); // =&gt; [1, 2]




Challenge

The argument to map above is fn =&gt; fn(). The challenge is to rewrite this function using point-free style. Your solution should work when it replaces the third line of the above program:

const fns = [() =&gt; 1, () =&gt; 2];
const result = fns.map(
  /* your solution should work when inserted here */
);
console.log(result); // =&gt; [1, 2]


fn =&gt; fn() is not a valid solution because it defines a parameter named fn. Writing a function in point-free style requires writing it without any variable or parameter names.

Note that map will pass three arguments to your solution function: currentValue: () =&gt; T, index: number, and array: Array&lt;() =&gt; T&gt;. The function for the solution must return the result of calling the currentValue function, so hard-coding 1 and 2 will not help. The functions being mapped over are guaranteed to ignore their arguments and their this value, so calling the function in any way will work.

Scoring

The best answer is the one that is represented by the fewest tokens when lexed. The ANTLR 4 JavaScript lexer is the official lexer for the sake of objectivity, but if you know how a lexer works you should be able to estimate how many tokens some JavaScript needs without having to read that link. For example, fn =&gt; fn() is composed of five tokens: fn =&gt; fn ( ).

However, I personally think that figuring out any answer is the fun part, so if this problem interests you, try to solve it yourself before scrolling down and seeing the answer.
Based on the answer by Rory O'Kane:


  10 tokens: Number.call.bind(String.call)


Try it online!

It is trivial, since Number.call, String.call, Object.call, Function.call, (function () {}).call, Function.prototype.call are all the same.

If Bind Operator Proposal is accepted, this could be simplified to:


  6 tokens: ::Function.call.call


Babel

BTW, if eval is allowed eval("Number.call.bind(String.call)") only use 4 tokens.