## lodash/fp
The `lodash/fp` module is an instance of `lodash` with its methods wrapped to
produce immutable auto-curried iteratee-first data-last methods.
## Installation
In a browser:
```html
```
In Node.js:
```js
// Load the fp build.
var _ = require('lodash/fp');
// Load a method category.
var object = require('lodash/fp/object');
// Load a single method for smaller builds with browserify/rollup/webpack.
var extend = require('lodash/fp/extend');
```
## Convert
Although `lodash/fp` & its method modules come pre-converted there are times when
you may want to convert another lodash package or create a customized conversion.
That’s when the `convert` module comes in handy.
```js
var convert = require('lodash/fp/convert');
// Convert by name.
var assign = convert('assign', require('lodash.assign'));
// Convert by object.
var fp = convert({
'assign': require('lodash.assign'),
'chunk': require('lodash.chunk')
});
// Convert by `lodash` instance.
var fp = convert(lodash.runInContext());
```
It’s even customizable.
```js
// Every option is `true` by default.
var filter = convert('filter', _.filter, {
// Specify capping iteratee arguments.
'cap': true,
// Specify currying.
'curry': true,
// Specify fixed arity.
'fixed': true,
// Specify immutable operations.
'immutable': true,
// Specify rearranging arguments.
'rearg': true
});
// Specify `cap` of `false` to create a function that doesn’t cap iteratee arguments.
var filter = convert('filter', _.filter, { 'cap': false });
filter(function(value, index) {
return index % 2 == 0;
})(['a', 'b', 'c']);
// => ['a', 'c']
```
## Mapping
Immutable auto-curried iteratee-first data-last methods sound great, but what’s
that really mean for each method? Below is a breakdown of the mapping used to
convert each method.
#### Capped Iteratee Arguments
Methods that cap iteratees to one argument:
<%= toFuncList(_.keys(_.pickBy(mapping.iterateeAry, _.partial(_.eq, _, 1)))) %>
Methods that cap iteratees to two arguments:
<%= toFuncList(_.keys(_.pickBy(mapping.iterateeAry, _.partial(_.eq, _, 2)))) %>
The iteratee of `mapKeys` is invoked with one argument: (key)
#### Fixed Arity
Methods with a fixed arity of one:
<%= toFuncList(mapping.aryMethod[1]) %>
Methods with a fixed arity of two:
<%= toFuncList(mapping.aryMethod[2]) %>
Methods with a fixed arity of three:
<%= toFuncList(mapping.aryMethod[3]) %>
Methods with a fixed arity of four:
<%= toFuncList(mapping.aryMethod[4]) %>
#### Rearranged Arguments
Methods with a fixed arity of two have an argument order of:
<%= toArgOrder(mapping.aryRearg[2]) %>
Methods with a fixed arity of three have an argument order of:
<%= toArgOrder(mapping.aryRearg[3]) %>
Methods with a fixed arity of four have an argument order of:
<%= toArgOrder(mapping.aryRearg[4]) %>
Methods with custom argument orders:
<%= _.map(mapping.methodRearg, function(orders, methodName) {
return ' * `_.' + methodName + '` has an order of ' + toArgOrder(orders);
}).join('\n') %>
Methods with unchanged argument orders:
<%= toFuncList(_.keys(mapping.skipRearg)) %>
The methods `partial` & `partialRight` accept an array of arguments to partially
apply as their second parameter.
#### New Methods
Methods created to accommodate Lodash’s variadic methods:
<%= toFuncList(_.keys(mapping.remap)) %>
#### Aliases
There are <%= _.size(mapping.aliasToReal) %> method aliases:
<%= _.map(mapping.aliasToReal, function(realName, alias) {
return ' * Added `_.' + alias + '` as an alias of `_.' + realName + '`';
}).join('\n') %>