mirror of
https://github.com/swc-project/swc.git
synced 2024-12-20 20:22:26 +03:00
64 lines
2.1 KiB
TypeScript
64 lines
2.1 KiB
TypeScript
// Loaded from https://deno.land/x/ramda@v0.27.2/source/map.js
|
|
|
|
|
|
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, R.pluck, R.project
|
|
* @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 = _curry2(_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;
|