no-extraneous-function-wrapping option to curry/partially apply a function

[jfmengels]

Add an option to no-extraneous-function-wrapping to error when a function, wrapping a non-Lodash function, can be made extraneous using curry.

Options

This rule supports the following options:

curry (name TBD...): When set to true, will lint an error even for non-Lodash functions, encouraging the practice of methods like _.curry, _.partial. Default is false. Note that this will probably lead to more false positives, as in some cases:

• it will not be possible (adding a last function argument to _.flow/_compose)
• or will need additional safe-guards like _.ary. For instance, array.map(parseInt) will probably cause you unexpected behavior, as parseInt will get called with parseInt(value, index) and parseInt takes two parameters (value and radix). Most Lodash-fp methods such as map therefore only pass one argument to their iteratee.

You can set the option in configuration like this:

"lodash-fp/no-extraneous-function-wrapping": ["error", {"curry": true}]

a.map((y) => foo(x, y))

// -->

// either
var _foo = _.curry(foo)
a.map(_foo(x))

// or
var _foo = _.partial(foo, x)
a.map(_foo)

a.map((x) => foo(x, y))
// -->
var _foo = _.curry(foo)
a.map(_foo(_, x))
// or
var _foo = _.partial(foo, _, y)
a.map(_foo);

Another option "placeholder": true could be given to enhance the normal and the curryed behavior by using a Lodash placeholder for curried functions

a.map((x) => _.find(x, y))
// -->
a.map(_.find(_, y))

// With `curry`
a.map((x) => foo(x, y))
// -->
a.map(_.curry(foo)(_, y))
// or
a.map(_.partial(foo, _, y))