ramda-adjunct 4.1.1 → 5.0.1

package/src/notEqual.js

@@ -1,31 +0,0 @@
-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
- */
-const notEqual = complement(equals);
-
-export default notEqual;

package/src/omitBy.js

@@ -1,25 +0,0 @@
-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 */
-const omitBy = useWith(pickBy, [complement, identity]);
-
-export default omitBy;

package/src/omitIndexes.js

@@ -1,27 +0,0 @@
-import { includes, curry, addIndex, reject } from 'ramda';
-
-// helpers
-const rejectIndexed = addIndex(reject);
-const containsIndex = curry((indexes, val, index) => includes(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']
- */
-const omitIndexes = curry((indexes, list) =>
-  rejectIndexed(containsIndex(indexes), list)
-);
-
-export default omitIndexes;

package/src/overlaps.js

@@ -1,32 +0,0 @@
-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
- */
-
-const overlaps = curryN(2, (list1, list2) => {
-  if (isEmpty(list1)) {
-    return true;
-  }
-
-  return pipe(intersection, isNotEmpty)(list1, list2);
-});
-
-export default overlaps;

package/src/padCharsEnd.js

@@ -1,37 +0,0 @@
-import { curry, invoker, flip } from 'ramda';
-
-import ponyfill from './internal/ponyfills/String.padEnd';
-import isFunction from './isFunction';
-
-export const padEndPonyfill = curry(ponyfill);
-
-export const 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'
- */
-const padCharsEnd = isFunction(String.prototype.padEnd)
-  ? padEndInvoker
-  : padEndPonyfill;
-
-export default padCharsEnd;

package/src/padCharsStart.js

@@ -1,35 +0,0 @@
-import { flip, invoker, curry } from 'ramda';
-
-import isFunction from './isFunction';
-import ponyfill from './internal/ponyfills/String.padStart';
-
-export const padStartInvoker = flip(invoker(2, 'padStart'));
-
-export const 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'
- */
-const padCharsStart = isFunction(String.prototype.padStart)
-  ? padStartInvoker
-  : padStartPonyfill;
-
-export default padCharsStart;

package/src/padEnd.js

@@ -1,25 +0,0 @@
-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  '
- */
-const padEnd = padCharsEnd(' ');
-
-export default padEnd;

package/src/padStart.js

@@ -1,23 +0,0 @@
-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'
- */
-const padStart = padCharsStart(' ');
-
-export default padStart;

package/src/pathNotEq.js

@@ -1,31 +0,0 @@
-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 a => [Idx] => {a} => Boolean
- * @sig Idx = String | Int | Symbol
- * @param {a} val The value to compare the nested property with
- * @param {Array} path The path of the nested property to use
- * @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 = RA.pathNotEq(90210, ['address', 'zipCode']);
- * R.filter(isFamous, users); //=> [ user2, user3 ]
- */
-/* eslint-enable max-len */
-const pathNotEq = complement(pathEq);
-
-export default pathNotEq;

package/src/pathOrLazy.js

@@ -1,30 +0,0 @@
-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"
- */
-const pathOrLazy = curryN(3, (defaultFn, path, obj) =>
-  when(
-    identical(defaultFn),
-    partial(unary(defaultFn), [obj]),
-    pathOr(defaultFn, path, obj)
-  )
-);
-
-export default pathOrLazy;

package/src/paths.js

@@ -1,26 +0,0 @@
-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]
- */
-const paths = curry((ps, obj) => ap([path(__, obj)], ps));
-
-export default paths;

package/src/pickIndexes.js

@@ -1,30 +0,0 @@
-import { filter, addIndex, curry, includes } from 'ramda';
-
-// helpers
-const filterIndexed = addIndex(filter);
-const containsIndex = curry((indexes, val, index) => includes(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']
- */
-const pickIndexes = curry((indexes, list) =>
-  filterIndexed(containsIndex(indexes), list)
-);
-
-export default pickIndexes;

package/src/propNotEq.js

@@ -1,30 +0,0 @@
-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  a -> String -> Object -> Boolean
- * @param {a} val The value to compare to
- * @param {String} name The property to pick
- * @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('brown', 'hair');
- *
- * R.filter(hasNotBrownHair, kids); //=> [abby, alois]
- */
-const propNotEq = complement(propEq);
-
-export default propNotEq;

package/src/rangeStep.js

@@ -1,37 +0,0 @@
-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); // => []
- */
-const rangeStep = curryN(3, (step, from, to) => {
-  const callback = step === 0 ? always(from) : (n) => from + step * n;
-  const rangeEnd = step === 0 ? to - from : floor((to - from) / step);
-
-  return map(callback, range(0, rangeEnd));
-});
-
-export default rangeStep;

package/src/reduceIndexed.js

@@ -1,31 +0,0 @@
-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"
- */
-const reduceIndexed = addIndex(reduce);
-
-export default reduceIndexed;

package/src/reduceP.js

@@ -1,96 +0,0 @@
-import { curryN, reduce, length } from 'ramda';
-
-import isUndefined from './isUndefined';
-import resolveP from './resolveP';
-import allP from './allP';
-
-/* eslint-disable max-len */
-/**
- * Given an `Iterable`(arrays are `Iterable`), or a promise of an `Iterable`,
- * which produces promises (or a mix of promises and values),
- * iterate over all the values in the `Iterable` into an array and
- * reduce the array to a value using the given iterator function.
- *
- * If the iterator function returns a promise, then the result of the promise is awaited,
- * before continuing with next iteration. If any promise in the array is rejected or a promise
- * returned by the iterator function is rejected, the result is rejected as well.
- *
- * If `initialValue` is `undefined` (or a promise that resolves to `undefined`) and
- * the `Iterable` contains only 1 item, the callback will not be called and
- * the `Iterable's` single item is returned. If the `Iterable` is empty, the callback
- * will not be called and `initialValue` is returned (which may be undefined).
- *
- * This function is basically equivalent to {@link http://bluebirdjs.com/docs/api/promise.reduce.html|bluebird.reduce}.
- *
- * @func reduceP
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/1.13.0|v1.13.0}
- * @category List
- * @typedef MaybePromise = Promise.<*> | *
- * @sig ((Promise a, MaybePromise b) -> Promise a) -> MaybePromise a -> MaybePromise [MaybePromise b] -> Promise a
- * @param {Function} fn The iterator function. Receives two values, the accumulator and the current element from the list
- * @param {*|Promise.<*>} acc The accumulator value
- * @param {Array.<*>|Promise.<Array<*|Promise.<*>>>} list The list to iterate over
- * @return {Promise} The final, accumulated value
- * @see {@link http://ramdajs.com/docs/#reduce|R.reduce}, {@link RA.reduceRightP|reduceRightP}, {@link http://bluebirdjs.com/docs/api/promise.reduce.html|bluebird.reduce}
- * @example
- *
- * RA.reduceP(
- *   (total, fileName) => fs
- *     .readFileAsync(fileName, 'utf8')
- *     .then(contents => total + parseInt(contents, 10)),
- *   0,
- *   ['file1.txt', 'file2.txt', 'file3.txt']
- * ); // => Promise(10)
- *
- * RA.reduceP(
- *   (total, fileName) => fs
- *     .readFileAsync(fileName, 'utf8')
- *     .then(contents => total + parseInt(contents, 10)),
- *   Promise.resolve(0),
- *   ['file1.txt', 'file2.txt', 'file3.txt']
- * ); // => Promise(10)
- *
- * RA.reduceP(
- *   (total, fileName) => fs
- *     .readFileAsync(fileName, 'utf8')
- *     .then(contents => total + parseInt(contents, 10)),
- *   0,
- *   [Promise.resolve('file1.txt'), 'file2.txt', 'file3.txt']
- * ); // => Promise(10)
- *
- * RA.reduceP(
- *   (total, fileName) => fs
- *     .readFileAsync(fileName, 'utf8')
- *     .then(contents => total + parseInt(contents, 10)),
- *   0,
- *   Promise.resolve([Promise.resolve('file1.txt'), 'file2.txt', 'file3.txt'])
- * ); // => Promise(10)
- *
- */
-/* esline-enable max-len */
-const reduceP = curryN(3, (fn, acc, list) =>
-  resolveP(list).then((iterable) => {
-    const listLength = length(iterable);
-
-    if (listLength === 0) {
-      return acc;
-    }
-
-    const reducer = reduce((accP, currentValueP) =>
-      accP
-        .then((previousValue) => allP([previousValue, currentValueP]))
-        .then(([previousValue, currentValue]) => {
-          if (isUndefined(previousValue) && listLength === 1) {
-            return currentValue;
-          }
-
-          return fn(previousValue, currentValue);
-        })
-    );
-
-    return reducer(resolveP(acc), iterable);
-  })
-);
-
-export default reduceP;

package/src/reduceRightP.js

@@ -1,101 +0,0 @@
-import { curryN, pipe, equals, reduceRight, length, concat } from 'ramda';
-
-import isUndefined from './isUndefined';
-import resolveP from './resolveP';
-import allP from './allP';
-
-// in older ramda versions the order of the arguments is flipped
-const flipArgs = pipe(reduceRight(concat, ''), equals('ba'))(['a', 'b']);
-
-/* eslint-disable max-len */
-/**
- * Given an `Iterable`(arrays are `Iterable`), or a promise of an `Iterable`,
- * which produces promises (or a mix of promises and values),
- * iterate over all the values in the `Iterable` into an array and
- * reduce the array to a value using the given iterator function.
- *
- * Similar to {@link RA.reduceP|reduceP} except moves through the input list from the right to the left.
- * The iterator function receives two values: (value, acc),
- * while the arguments' order of reduceP's iterator function is (acc, value).
- *
- * @func reduceRightP
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/1.13.0|v1.13.0}
- * @category List
- * @typedef MaybePromise = Promise.<*> | *
- * @sig ((MaybePromise b, Promise a) -> Promise a) -> MaybePromise a -> MaybePromise [MaybePromise b] -> Promise a
- * @param {Function} fn The iterator function. Receives two values, the current element from the list and the accumulator
- * @param {*|Promise.<*>} acc The accumulator value
- * @param {Array.<*>|Promise.<Array<*|Promise.<*>>>} list The list to iterate over
- * @return {Promise} The final, accumulated value
- * @see {@link RA.reduceP|reduceP}, {@link http://bluebirdjs.com/docs/api/promise.reduce.html|bluebird.reduce}
- * @example
- *
- * RA.reduceRightP(
- *   (fileName, total) => fs
- *     .readFileAsync(fileName, 'utf8')
- *     .then(contents => total + parseInt(contents, 10)),
- *   0,
- *   ['file1.txt', 'file2.txt', 'file3.txt']
- * ); // => Promise(10)
- *
- * RA.reduceRightP(
- *   (fileName, total) => fs
- *     .readFileAsync(fileName, 'utf8')
- *     .then(contents => total + parseInt(contents, 10)),
- *   Promise.resolve(0),
- *   ['file1.txt', 'file2.txt', 'file3.txt']
- * ); // => Promise(10)
- *
- * RA.reduceRightP(
- *   (fileName, total) => fs
- *     .readFileAsync(fileName, 'utf8')
- *     .then(contents => total + parseInt(contents, 10)),
- *   0,
- *   [Promise.resolve('file1.txt'), 'file2.txt', 'file3.txt']
- * ); // => Promise(10)
- *
- * RA.reduceRightP(
- *   (fileName, total) => fs
- *     .readFileAsync(fileName, 'utf8')
- *     .then(contents => total + parseInt(contents, 10)),
- *   0,
- *   Promise.resolve([Promise.resolve('file1.txt'), 'file2.txt', 'file3.txt'])
- * ); // => Promise(10)
- *
- */
-/* esline-enable max-len */
-const reduceRightP = curryN(3, (fn, acc, list) =>
-  resolveP(list).then((iterable) => {
-    const listLength = length(iterable);
-
-    if (listLength === 0) {
-      return acc;
-    }
-
-    const reducer = reduceRight((arg1, arg2) => {
-      let accP;
-      let currentValueP;
-
-      if (flipArgs) {
-        [accP, currentValueP] = [arg1, arg2];
-      } else {
-        [accP, currentValueP] = [arg2, arg1];
-      }
-
-      return accP
-        .then((previousValue) => allP([previousValue, currentValueP]))
-        .then(([previousValue, currentValue]) => {
-          if (isUndefined(previousValue) && listLength === 1) {
-            return currentValue;
-          }
-
-          return fn(currentValue, previousValue);
-        });
-    });
-
-    return reducer(resolveP(acc), iterable);
-  })
-);
-
-export default reduceRightP;