66 lines
2 KiB
JavaScript
66 lines
2 KiB
JavaScript
import _curry2 from "./internal/_curry2.js";
|
|
import _dispatchable from "./internal/_dispatchable.js";
|
|
import _map from "./internal/_map.js";
|
|
import _reduce from "./internal/_reduce.js";
|
|
import _xmap from "./internal/_xmap.js";
|
|
import curryN from "./curryN.js";
|
|
import keys from "./keys.js";
|
|
/**
|
|
* Takes a function and
|
|
* a [functor](https://github.com/fantasyland/fantasy-land#functor),
|
|
* applies the function to each of the functor's values, and returns
|
|
* a functor of the same shape.
|
|
*
|
|
* Ramda provides suitable `map` implementations for `Array` and `Object`,
|
|
* so this function may be applied to `[1, 2, 3]` or `{x: 1, y: 2, z: 3}`.
|
|
*
|
|
* Dispatches to the `map` method of the second argument, if present.
|
|
*
|
|
* Acts as a transducer if a transformer is given in list position.
|
|
*
|
|
* Also treats functions as functors and will compose them together.
|
|
*
|
|
* @func
|
|
* @memberOf R
|
|
* @since v0.1.0
|
|
* @category List
|
|
* @sig Functor f => (a -> b) -> f a -> f b
|
|
* @param {Function} fn The function to be called on every element of the input `list`.
|
|
* @param {Array} list The list to be iterated over.
|
|
* @return {Array} The new list.
|
|
* @see R.transduce, R.addIndex
|
|
* @example
|
|
*
|
|
* const double = x => x * 2;
|
|
*
|
|
* R.map(double, [1, 2, 3]); //=> [2, 4, 6]
|
|
*
|
|
* R.map(double, {x: 1, y: 2, z: 3}); //=> {x: 2, y: 4, z: 6}
|
|
* @symb R.map(f, [a, b]) = [f(a), f(b)]
|
|
* @symb R.map(f, { x: a, y: b }) = { x: f(a), y: f(b) }
|
|
* @symb R.map(f, functor_o) = functor_o.map(f)
|
|
*/
|
|
|
|
var map =
|
|
/*#__PURE__*/
|
|
_curry2(
|
|
/*#__PURE__*/
|
|
_dispatchable(['fantasy-land/map', 'map'], _xmap, function map(fn, functor) {
|
|
switch (Object.prototype.toString.call(functor)) {
|
|
case '[object Function]':
|
|
return curryN(functor.length, function () {
|
|
return fn.call(this, functor.apply(this, arguments));
|
|
});
|
|
|
|
case '[object Object]':
|
|
return _reduce(function (acc, key) {
|
|
acc[key] = fn(functor[key]);
|
|
return acc;
|
|
}, {}, keys(functor));
|
|
|
|
default:
|
|
return _map(fn, functor);
|
|
}
|
|
}));
|
|
|
|
export default map; |