ramda-adjunct 2.34.0

package/es/nonePass.js

@@ -0,0 +1,31 @@
+import { complement, compose, anyPass, curryN } from 'ramda';
+/**
+ * Takes a list of predicates and returns a predicate that returns true for a given list of
+ * arguments if none of the provided predicates are satisfied by those arguments. It is the
+ * complement of Ramda's anyPass.
+ *
+ * The function returned is a curried function whose arity matches that of the
+ * highest-arity predicate.
+ *
+ * @func nonePass
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.5.0|v2.5.0}
+ * @category Logic
+ * @sig [(*... -> Boolean)] -> (*... -> Boolean)
+ * @param {Array} predicates An array of predicates to check
+ * @return {Function} The combined predicate
+ * @see {@link http://ramdajs.com/docs/#anyPass|R.anyPass}
+ * @example
+ *
+ * const gt10 = R.gt(R.__, 10)
+ * const even = (x) => x % 2 === 0;
+ * const f = RA.nonePass([gt10, even]);
+ *
+ * f(12); //=> false
+ * f(8); //=> false
+ * f(11); //=> false
+ * f(9); //=> true
+ */
+
+var nonePass = curryN(1, compose(complement, anyPass));
+export default nonePass;

package/es/noop.js

@@ -0,0 +1,19 @@
+import { always } from 'ramda';
+import stubUndefined from './stubUndefined';
+/**
+ * A function that performs no operations.
+ *
+ * @func noop
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.0.0|v1.0.0}
+ * @category Function
+ * @sig ... -> undefined
+ * @return {undefined}
+ * @example
+ *
+ * RA.noop(); //=> undefined
+ * RA.noop(1, 2, 3); //=> undefined
+ */
+
+var noop = always(stubUndefined());
+export default noop;

package/es/nor.js

@@ -0,0 +1,28 @@
+import { or, complement } from 'ramda';
+/**
+ * Returns true if both arguments are falsy; false otherwise.
+ *
+ * @func nor
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.20.0|v2.20.0}
+ * @category Logic
+ * @sig a -> b -> a ⊽ b
+ * @param {*} a
+ * @param {*} b
+ * @return {boolean} true if both arguments are falsy
+ * @see {@link RA.neither|neither}
+ * @example
+ *
+ * RA.nor(true, true); //=> false
+ * RA.nor(false, true); //=> false
+ * RA.nor(true, false); //=> false
+ * RA.nor(false, false); //=> true
+ * RA.nor(1, 1); //=> false
+ * RA.nor(1, 0); //=> false
+ * RA.nor(0, 1); //=> false
+ * RA.nor(0, 0); //=> true
+ */
+
+var nor = complement(or); // eslint-disable-line ramda/complement-simplification
+
+export default nor;

package/es/notAllPass.js

@@ -0,0 +1,31 @@
+import { curry, complement, compose, allPass } from 'ramda';
+/**
+ * Takes a list of predicates and returns a predicate that returns true for a given list of
+ * arguments if one or more of the provided predicates is not satisfied by those arguments. It is
+ * the complement of Ramda's allPass.
+ *
+ * The function returned is a curried function whose arity matches that of the
+ * highest-arity predicate.
+ *
+ * @func notAllPass
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.4.0|v2.4.0}
+ * @category Logic
+ * @sig [(*... -> Boolean)] -> (*... -> Boolean)
+ * @param {Array} predicates An array of predicates to check
+ * @return {Function} The combined predicate
+ * @see {@link http://ramdajs.com/docs/#allPass|R.allPass}
+ * @example
+ *
+ * const gt10 = R.gt(R.__, 10)
+ * const even = (x) => x % 2 === 0;
+ * const f = RA.notAllPass([gt10, even]);
+ *
+ * f(12); //=> false
+ * f(8); //=> true
+ * f(11); //=> true
+ * f(9); //=> true
+ */
+
+var notAllPass = curry(compose(complement, allPass));
+export default notAllPass;

package/es/notAllUnique.js

@@ -0,0 +1,23 @@
+import { complement } from 'ramda';
+import allUnique from './allUnique';
+/**
+ * Returns true if at least one item of the list is repeated. `R.equals` is used to determine equality.
+ *
+ * @func notAllUnique
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.22.0|v2.22.0}
+ * @category List
+ * @sig [a] -> Boolean
+ * @param {Array} list The list of values
+ * @return {boolean}
+ * @see {@link RA.allUnique|allUnique}, {@link https://ramdajs.com/docs/#equals|equals}
+ * @example
+ *
+ * RA.notAllUnique([ 1, 1, 2, 3 ]); //=> true
+ * RA.notAllUnique([ 1, 2, 3, 4 ]); //=> false
+ * RA.notAllUnique([]); //=> false
+ *
+ */
+
+var notAllUnique = complement(allUnique);
+export default notAllUnique;

package/es/notBoth.js

@@ -0,0 +1,39 @@
+import { curry, compose, complement, both } from 'ramda';
+/* eslint-disable max-len */
+
+/**
+ * A function which calls the two provided functions and returns the complement of `&&`ing the
+ * results.
+ * It returns true if the first function is false-y and the complement of the second function
+ * otherwise. Note that this is short-circuited, meaning that the second function will not be
+ * invoked if the first returns a false-y value. In short it will return true unless both predicates
+ * return true.
+ *
+ * In addition to functions, `RA.notBoth` also accepts any fantasy-land compatible
+ * applicative functor.
+ *
+ * @func notBoth
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.3.0|v2.3.0}
+ * @category Logic
+ * @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)
+ * @param {Function} f A predicate
+ * @param {Function} g Another predicate
+ * @return {Function} Returns a function that applies its arguments to `f` and `g` and returns the complement of `&&`ing their outputs together.
+ * @see {@link http://ramdajs.com/docs/#both|R.both}
+ * @example
+ *
+ * const gt10 = R.gt(R.__, 10)
+ * const even = (x) => x % 2 === 0;
+ * const f = RA.notBoth(gt10, even);
+ *
+ * f(12); //=> false
+ * f(8); //=> true
+ * f(11); //=> true
+ * f(9); //=> true
+ */
+
+/* eslint-enable max-len */
+
+var notBoth = curry(compose(complement, both));
+export default notBoth;

package/es/notEqual.js

@@ -0,0 +1,30 @@
+import { complement, equals } from 'ramda';
+/**
+ * Returns `true` if its arguments are not equivalent, `false` otherwise. Handles
+ * cyclical data structures.
+ *
+ * Dispatches symmetrically to the `equals` methods of both arguments, if
+ * present.
+ *
+ * @func notEqual
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.29.0|v2.29.0}
+ * @category Relation
+ * @sig a -> b -> Boolean
+ * @param {*} a
+ * @param {*} b
+ * @return {Boolean}
+ * @see {@link https://ramdajs.com/docs/#equals|equals}
+ * @example
+ *
+ * RA.notEqual(1, 1); //=> false
+ * RA.notEqual(1, '1'); //=> true
+ * RA.notEqual([1, 2, 3], [1, 2, 3]); //=> false
+ *
+ * const a = {}; a.v = a;
+ * const b = {}; b.v = b;
+ * RA.notEqual(a, b); //=> false
+ */
+
+var notEqual = complement(equals);
+export default notEqual;

package/es/omitBy.js

@@ -0,0 +1,26 @@
+import { complement, identity, pickBy, useWith } from 'ramda';
+/* eslint-disable max-len */
+
+/**
+ * Returns a partial copy of an object containing only the keys
+ * that don't satisfy the supplied predicate.
+ *
+ * @func omitBy
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.6.0|v2.6.0}
+ * @category Object
+ * @sig ((v, k) -> Boolean) -> {k: v} -> {k: v}
+ * @param {!Function} pred A predicate to determine whether or not a key should be included on the output object
+ * @param {!Object} obj The object to copy from
+ * @return {!Object} A new object only with properties that don't satisfy `pred`
+ *
+ * @example
+ *
+ * const isLowerCase = (val, key) => key.toLowerCase() === key;
+ * RA.omitBy(isLowerCase, {a: 1, b: 2, A: 3, B: 4}); //=> {A: 3, B: 4}
+ */
+
+/* eslint-enable max-len */
+
+var omitBy = useWith(pickBy, [complement, identity]);
+export default omitBy;

package/es/omitIndexes.js

@@ -0,0 +1,27 @@
+import { contains, curry, addIndex, reject } from 'ramda'; // helpers
+
+var rejectIndexed = addIndex(reject);
+var containsIndex = curry(function (indexes, val, index) {
+  return contains(index, indexes);
+});
+/**
+ * Returns a partial copy of an array omitting the indexes specified.
+ *
+ * @func omitIndexes
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.19.0|v1.19.0}
+ * @category List
+ * @sig [Int] -> [a] -> [a]
+ * @see {@link http://ramdajs.com/docs/#omit|R.omit}, {@link RA.pickIndexes|pickIndexes}
+ * @param {!Array} indexes The array of indexes to omit from the new array
+ * @param {!Array} list The array to copy from
+ * @return {!Array} The new array with omitted indexes
+ * @example
+ *
+ * RA.omitIndexes([-1, 1, 3], ['a', 'b', 'c', 'd']); //=> ['a', 'c']
+ */
+
+var omitIndexes = curry(function (indexes, list) {
+  return rejectIndexed(containsIndex(indexes), list);
+});
+export default omitIndexes;

package/es/overlaps.js

@@ -0,0 +1,29 @@
+import { pipe, intersection, isEmpty, curryN } from 'ramda';
+import isNotEmpty from './isNotEmpty';
+/**
+ * Returns true if two lists have at least one element common to both lists.
+ *
+ * @func overlaps
+ * @memberOf RA
+ * @category Relation
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.30.0|v2.30.0}
+ * @sig [a] -> [a] -> Boolean
+ * @param {Array} list1 The first list
+ * @param {Array} list2 The second list
+ * @return {boolean} True if two lists have at least one element common to both lists
+ * @example
+ *
+ * RA.overlaps(['-v', '--verbose'], ['node', 'script.js', '-v']); //=> true
+ * RA.overlaps(['-v', '--verbose'], []); //=> false
+ * RA.overlaps([1, 2, 3], [3, 4, 5]); //=> true
+ * RA.overlaps([1, 2, 3], [4, 5]); //=> false
+ */
+
+var overlaps = curryN(2, function (list1, list2) {
+  if (isEmpty(list1)) {
+    return true;
+  }
+
+  return pipe(intersection, isNotEmpty)(list1, list2);
+});
+export default overlaps;

package/es/padCharsEnd.js

@@ -0,0 +1,31 @@
+import { curry, invoker, flip } from 'ramda';
+import ponyfill from './internal/ponyfills/String.padEnd';
+import isFunction from './isFunction';
+export var padEndPonyfill = curry(ponyfill);
+export var padEndInvoker = flip(invoker(2, 'padEnd'));
+/**
+ * The function pads the current string with a given string
+ * (repeated, if needed) so that the resulting string reaches a given length.
+ * The padding is applied from the end of the current string.
+ *
+ * @func padCharsEnd
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.22.0|v2.22.0}
+ * @category String
+ * @sig String -> Number -> String -> String
+ * @param {string} padString The string to pad the current string with
+ * @param {number} targetLength The length of the resulting string once
+ * the current string has been padded
+ * @param {string} value String value to be padded
+ * @return {string} A new string of the specified length with the pad string
+ * applied at the end of the current string
+ * @see {@link RA.padEnd|padEnd}, {@link RA.padCharsStart|padCharsStart}, {@link RA.padStart|padStart}
+ * @example
+ *
+ * RA.padCharsEnd('-', 3, 'a'); // => 'a--'
+ * RA.padCharsEnd('foo', 10, 'abc'); // => 'abcfoofoof'
+ * RA.padCharsEnd('123456', 6, 'abc'); // => 'abc123'
+ */
+
+var padCharsEnd = isFunction(String.prototype.padEnd) ? padEndInvoker : padEndPonyfill;
+export default padCharsEnd;

package/es/padCharsStart.js

@@ -0,0 +1,29 @@
+import { flip, invoker, curry } from 'ramda';
+import isFunction from './isFunction';
+import ponyfill from './internal/ponyfills/String.padStart';
+export var padStartInvoker = flip(invoker(2, 'padStart'));
+export var padStartPonyfill = curry(ponyfill);
+/**
+ * The function pads the current string with a given string
+ * (repeated, if needed) so that the resulting string reaches a given length.
+ * The padding is applied from the start of the current string.
+ *
+ * @func padCharsStart
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.22.0|v2.22.0}
+ * @category String
+ * @sig String -> Number -> String -> String
+ * @param {string} padString The string to pad the current string with
+ * @param {number} targetLength The length of the resulting string once the current string has been padded
+ * @param {string} value String value to be padded
+ * @return {string} A new string of the specified length with the pad string on the start of current string
+ * @see {@link RA.padStart|padStart}, {@link RA.padEnd|padEnd}, {@link RA.padCharsEnd|padCharsEnd}
+ * @example
+ *
+ * RA.padCharsStart('-', 3, 'a'); // => '--a'
+ * RA.padCharsStart('foo', 10, 'abc'); // => 'foofoofabc'
+ * RA.padCharsStart('123456', 6, 'abc'); // => '123abc'
+ */
+
+var padCharsStart = isFunction(String.prototype.padStart) ? padStartInvoker : padStartPonyfill;
+export default padCharsStart;

package/es/padEnd.js

@@ -0,0 +1,24 @@
+import padCharsEnd from './padCharsEnd';
+/**
+ * The function pads the current string with an empty string
+ * so that the resulting string reaches a given length.
+ * The padding is applied from the end of the current string.
+ *
+ * @func padEnd
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.22.0|v2.22.0}
+ * @category String
+ * @sig Number -> String -> String
+ * @param {number} targetLength The length of the resulting string once
+ * the current string has been padded
+ * @param {string} value String value to be padded
+ * @return {string} A new string of the specified length with the pad string
+ * applied at the end of the current string
+ * @see {@link RA.padCharsEnd|padCharsEnd}, {@link RA.padCharsStart|padCharsStart}, {@link RA.padStart|padStart}
+ * @example
+ *
+ * RA.padEnd(3, 'a'); // => 'a  '
+ */
+
+var padEnd = padCharsEnd(' ');
+export default padEnd;

package/es/padStart.js

@@ -0,0 +1,22 @@
+import padCharsStart from './padCharsStart';
+/**
+ * Pads string on the left side if it's shorter than length.
+ *
+ * @func padStart
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.25.0|v2.25.0}
+ * @category String
+ * @sig Number -> String -> String
+ * @param {number} targetLength The length of the resulting string once
+ * the current string has been padded
+ * @param {string} value String value to be padded
+ * @return {string} A new string of the specified length with the empty string
+ * applied to the beginning of the current string
+ * @see {@link RA.padCharsEnd|padCharsEnd}, {@link RA.padCharsStart|padCharsStart}, {@link RA.padEnd|padEnd}
+ * @example
+ *
+ * RA.padStart(3, 'a'); // => '  a'
+ */
+
+var padStart = padCharsStart(' ');
+export default padStart;

package/es/pathNotEq.js

@@ -0,0 +1,32 @@
+import { pathEq, complement } from 'ramda';
+/* eslint-disable max-len */
+
+/**
+ * Determines whether a nested path on an object doesn't have a specific value,
+ * in R.equals terms. Most likely used to filter a list.
+ *
+ * @func pathNotEq
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.4.0|v2.4.0}
+ * @category Relation
+ * @sig [Idx] => a => {a} => Boolean
+ * @sig Idx = String | Int
+ * @param {Array} path The path of the nested property to use
+ * @param {a} val The value to compare the nested property with
+ * @param {Object} object The object to check the nested property in
+ * @return {boolean} Returns Boolean `false` if the value equals the nested object property, `true` otherwise
+ * @see {@link http://ramdajs.com/docs/#pathEq|R.pathEq}
+ * @example
+ *
+ * const user1 = { address: { zipCode: 90210 } };
+ * const user2 = { address: { zipCode: 55555 } };
+ * const user3 = { name: 'Bob' };
+ * const users = [ user1, user2, user3 ];
+ * const isFamous = R.pathNotEq(['address', 'zipCode'], 90210);
+ * R.filter(isFamous, users); //=> [ user2, user3 ]
+ */
+
+/* eslint-enable max-len */
+
+var pathNotEq = complement(pathEq);
+export default pathNotEq;

package/es/pathOrLazy.js

@@ -0,0 +1,25 @@
+import { curryN, identical, partial, pathOr, unary, when } from 'ramda';
+/**
+ * If the given, non-null object has a value at the given path, returns the value at that path.
+ * Otherwise returns the result of invoking the provided function with the object.
+ *
+ * @func pathOrLazy
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.22.0|v2.22.0}
+ * @category Object
+ * @typedef Idx = String | Int
+ * @sig ({a} -> a) -> [Idx] -> {a} -> a
+ * @param {Function} defaultFn The function that will return the default value.
+ * @param {Array} path The path to use.
+ * @param {Object} obj The object to retrieve the nested property from.
+ * @return {*} The data at `path` of the supplied object or the default value.
+ * @example
+ *
+ * RA.pathOrLazy(() => 'N/A', ['a', 'b'], {a: {b: 2}}); //=> 2
+ * RA.pathOrLazy(() => 'N/A', ['a', 'b'], {c: {b: 2}}); //=> "N/A"
+ */
+
+var pathOrLazy = curryN(3, function (defaultFn, path, obj) {
+  return when(identical(defaultFn), partial(unary(defaultFn), [obj]), pathOr(defaultFn, path, obj));
+});
+export default pathOrLazy;

package/es/paths.js

@@ -0,0 +1,27 @@
+import { curry, ap, path, __ } from 'ramda';
+/**
+ * Acts as multiple path: arrays of paths in, array of values out. Preserves order.
+ *
+ * @func paths
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.2.0|v1.2.0}
+ * @category List
+ * @sig  [[k]] -> {k: v} - [v]
+ * @param {Array} ps The property paths to fetch
+ * @param {Object} obj The object to query
+ * @return {Array} The corresponding values or partially applied function
+ * @see {@link https://github.com/ramda/ramda/wiki/Cookbook#derivative-of-rprops-for-deep-fields|Ramda Cookbook}, {@link http://ramdajs.com/docs/#props|R.props}
+ * @example
+ *
+ * const obj = {
+ *   a: { b: { c: 1 } },
+ *   x: 2,
+ * };
+ *
+ * RA.paths([['a', 'b', 'c'], ['x']], obj); //=> [1, 2]
+ */
+
+var paths = curry(function (ps, obj) {
+  return ap([path(__, obj)], ps);
+});
+export default paths;

package/es/pickIndexes.js

@@ -0,0 +1,30 @@
+import { filter, addIndex, curry, contains } from 'ramda'; // helpers
+
+var filterIndexed = addIndex(filter);
+var containsIndex = curry(function (indexes, val, index) {
+  return contains(index, indexes);
+});
+/**
+ * Picks values from list by indexes.
+ *
+ * Note: pickIndexes will skip non existing indexes. If you want to include them
+ * use ramda's `props` function.
+ *
+ * @func pickIndexes
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.1.0|v1.1.0}
+ * @category List
+ * @sig  [Number] -> [a] -> [a]
+ * @param {Array} indexes The indexes to pick
+ * @param {Array} list The list to pick values from
+ * @return {Array} New array containing only values at `indexes`
+ * @see {@link http://ramdajs.com/docs/#pick|R.pick}, {@link RA.omitIndexes|omitIndexes}
+ * @example
+ *
+ * RA.pickIndexes([0, 2], ['a', 'b', 'c']); //=> ['a', 'c']
+ */
+
+var pickIndexes = curry(function (indexes, list) {
+  return filterIndexed(containsIndex(indexes), list);
+});
+export default pickIndexes;

package/es/propNotEq.js

@@ -0,0 +1,29 @@
+import { propEq, complement } from 'ramda';
+/**
+ * Returns true if the specified object property is not equal,
+ * in R.equals terms, to the given value; false otherwise.
+ *
+ * @func propNotEq
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.3.0|v2.3.0}
+ * @category Relation
+ * @sig  String -> a -> Object -> Boolean
+ * @param {String} name The property to pick
+ * @param {a} val The value to compare to
+ * @param {Object} object The object, that presumably contains value under the property
+ * @return {boolean} Comparison result
+ * @see {@link http://ramdajs.com/docs/#propEq|R.propEq}
+ * @example
+ *
+ * const abby = { name: 'Abby', age: 7, hair: 'blond' };
+ * const fred = { name: 'Fred', age: 12, hair: 'brown' };
+ * const rusty = { name: 'Rusty', age: 10, hair: 'brown' };
+ * const alois = { name: 'Alois', age: 15, disposition: 'surly' };
+ * const kids = [abby, fred, rusty, alois];
+ * const hasNotBrownHair = RA.propNotEq('hair', 'brown');
+ *
+ * R.filter(hasNotBrownHair, kids); //=> [abby, alois]
+ */
+
+var propNotEq = complement(propEq);
+export default propNotEq;

package/es/rangeStep.js

@@ -0,0 +1,36 @@
+import { curryN, map, range, always } from 'ramda';
+import floor from './floor';
+/**
+ * Creates an array of numbers (positive and/or negative) progressing from start up to, but not including, end.
+ *
+ * `Note`: JavaScript follows the IEEE-754 standard for resolving floating-point values which can produce unexpected results.
+ *
+ * @func rangeStep
+ * @memberOf RA
+ * @category List
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.30.0|v2.30.0}
+ * @sig Number -> Number -> Number -> [Number]
+ * @param {number} step The value to increment or decrement by
+ * @param {number} from The start of the range
+ * @param {number} to The end of the range
+ * @return {number[]} Returns the range of numbers
+ * @see {@link http://ramdajs.com/docs/#range|R.range}
+ * @example
+ *
+ * RA.rangeStep(1, 0, 4); // => [0, 1 ,2, 3]
+ * RA.rangeStep(-1, 0, -4); // => [0, -1, -2, -3]
+ * RA.rangeStep(1, 1, 5); // => [1, 2, 3, 4]
+ * RA.rangeStep(5, 0, 20); // => [0, 5, 10, 15]
+ * RA.rangeStep(-1, 0, -4); // => [0, -1, -2, -3]
+ * RA.rangeStep(0, 1, 4); // => [1, 1, 1]
+ * RA.rangeStep(1, 0, 0); // => []
+ */
+
+var rangeStep = curryN(3, function (step, from, to) {
+  var callback = step === 0 ? always(from) : function (n) {
+    return from + step * n;
+  };
+  var rangeEnd = step === 0 ? to - from : floor((to - from) / step);
+  return map(callback, range(0, rangeEnd));
+});
+export default rangeStep;

package/es/reduceIndexed.js

@@ -0,0 +1,30 @@
+import { addIndex, reduce } from 'ramda';
+/**
+ * {@link http://ramdajs.com/docs/#reduce|R.reduce} function that more closely resembles Array.prototype.reduce.
+ * It takes two new parameters to its callback function: the current index, and the entire list.
+ *
+ * `reduceIndexed` implementation is simple : `
+ * const reduceIndexed = R.addIndex(R.reduce);
+ * `
+ * @func reduceIndexed
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.5.0|v2.5.0}
+ * @category List
+ * @typedef Idx = Number
+ * @sig ((a, b, Idx, [b]) => a) -> a -> [b] -> a
+ * @param {Function} fn The iterator function. Receives four values,
+ * the accumulator, the current element from the array, index and the entire list
+ * @param {*} acc The accumulator value
+ * @param {Array} list The list to iterate over
+ * @return {*} The final, accumulated value
+ * @see {@link http://ramdajs.com/docs/#addIndex|R.addIndex}, {@link http://ramdajs.com/docs/#reduce|R.reduce}
+ * @example
+ *
+ * const initialList = ['f', 'o', 'o', 'b', 'a', 'r'];
+ *
+ * reduceIndexed((acc, val, idx, list) => acc + '-' + val + idx, '', initialList);
+ * //=> "-f0-o1-o2-b3-a4-r5"
+ */
+
+var reduceIndexed = addIndex(reduce);
+export default reduceIndexed;