ramda-adjunct 5.0.0 → 5.1.0

package/src/mergeProps.js

@@ -1,27 +0,0 @@
-import { curryN, pipe, mergeAll, props } from 'ramda';
-
-/**
- * Functional equivalent of merging object properties with object spread operator.
- *
- * @func mergeProps
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/1.17.0|v1.17.0}
- * @category Object
- * @sig [k] -> {k: {a}} -> {a}
- * @see {@link RA.mergePaths|mergePaths}
- * @param {!Array} ps The property names to merge
- * @param {!Object} obj The object to query
- * @return {!Object} The object composed of merged properties of obj
- * @example
- *
- * const obj = {
- *   foo: { fooInner: 1 },
- *   bar: { barInner: 2 }
- * };
- *
- * { ...obj.foo, ...obj.bar }; //=> { fooInner: 1, barInner: 2 }
- * RA.mergeProps(['foo', 'bar'], obj); //=> { fooInner: 1, barInner: 2 }
- */
-const mergeProps = curryN(2, pipe(props, mergeAll));
-
-export default mergeProps;

package/src/move.js

@@ -1,26 +0,0 @@
-import { compose, curry, insert, nth, remove } from 'ramda';
-
-/**
- * Returns a new list with the item at the position `fromIdx` moved to the position `toIdx`. If the
- * `toIdx` is out of the `list` range, the item will be placed at the last position of the `list`.
- * When negative indices are provided, the behavior of the move is unspecified.
- *
- * @func move
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.8.0|v2.8.0}
- * @category List
- * @sig Number -> Number -> [a] -> [a]
- * @param {number} fromIdx The position of item to be moved
- * @param {number} toIdx The position of item after move
- * @param {Array} list The list containing the item to be moved
- * @return {Array}
- * @example
- *
- * const list = ['a', 'b', 'c', 'd', 'e'];
- * RA.move(1, 3, list) //=> ['a', 'c', 'd', 'b', 'e']
- */
-const move = curry((fromIdx, toIdx, list) =>
-  compose(insert(toIdx, nth(fromIdx, list)), remove(fromIdx, 1))(list)
-);
-
-export default move;

package/src/nand.js

@@ -1,27 +0,0 @@
-import { and, complement } from 'ramda';
-
-/**
- * Returns false if both arguments are truthy; true otherwise.
- *
- * @func nand
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.19.0|v2.19.0}
- * @category Logic
- * @sig a -> b -> Boolean
- * @param {*} a
- * @param {*} b
- * @return {Boolean} false if both arguments are truesy
- * @example
- *
- * RA.nand(true, true); //=> false
- * RA.nand(false, true); //=> true
- * RA.nand(true, false); //=> true
- * RA.nand(false, false); //=> true
- * RA.nand(1.0, 1.0); //=> false
- * RA.nand(1.0, 0); //=> true
- * RA.nand(0, 1.0); //=> true
- * RA.nand(0, 0); //=> true
- */
-const nand = complement(and); // eslint-disable-line ramda/complement-simplification
-
-export default nand;

package/src/neither.js

@@ -1,38 +0,0 @@
-import { curry, compose, complement, either } from 'ramda';
-
-/* eslint-disable max-len */
-/**
- * A function which calls the two provided functions and returns the complement of `||`ing the
- * results.
- * It returns false if the first function is truth-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 truth-y value. In short it will return true if neither predicate
- * returns true.
- *
- * In addition to functions, `RA.neither` also accepts any fantasy-land compatible
- * applicative functor.
- *
- * @func neither
- * @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/#either|R.either}, {@link http://ramdajs.com/docs/#or|R.or}
- * @example
- *
- * const gt10 = R.gt(R.__, 10)
- * const even = (x) => x % 2 === 0;
- * const f = RA.neither(gt10, even);
- *
- * f(12); //=> false
- * f(8); //=> false
- * f(11); //=> false
- * f(9); //=> true
- */
-/* eslint-enable max-len */
-const neither = curry(compose(complement, either));
-
-export default neither;

package/src/noneP.js

@@ -1,35 +0,0 @@
-import { curryN, map, pipe } from 'ramda';
-
-import allP from './allP.js';
-import rejectP from './rejectP.js';
-import resolveP from './resolveP.js';
-
-/**
- * Returns a Promise that is resolved with an array of reasons when all of the provided Promises reject, or rejected when any Promise is resolved.
- * This pattern is like allP, but fulfillments and rejections are transposed - rejections become the fulfillment values and vice versa.
- *
- * @func noneP
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.22.0|v2.22.0}
- * @category Function
- * @sig [Promise a] -> Promise [a]
- * @param {Iterable.<*>} iterable An iterable object such as an Array or String
- * @return {Promise} A Promise that is resolved with a list of rejection reasons if all Promises are rejected, or a Promise that is rejected with the fulfillment value of the first Promise that resolves.
- * @see {@link RA.allP|allP}
- * @example
- *
- * RA.noneP([Promise.reject('hello'), Promise.reject('world')]); //=> Promise(['hello', 'world'])
- * RA.noneP([]); //=> Promise([])
- * RA.noneP([Promise.reject(), Promise.resolve('hello world')]); //=> Promise('hello world')
- * RA.noneP([Promise.reject(), 'hello world']); //=> Promise('hello world')
- */
-const noneP = curryN(
-  1,
-  pipe(
-    map(resolveP),
-    map((p) => p.then(rejectP, resolveP)),
-    allP
-  )
-);
-
-export default noneP;

package/src/nonePass.js

@@ -1,32 +0,0 @@
-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
- */
-const nonePass = curryN(1, compose(complement, anyPass));
-
-export default nonePass;

package/src/noop.js

@@ -1,21 +0,0 @@
-import { always } from 'ramda';
-
-import stubUndefined from './stubUndefined.js';
-
-/**
- * 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
- */
-const noop = always(stubUndefined());
-
-export default noop;

package/src/nor.js

@@ -1,28 +0,0 @@
-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
- */
-const nor = complement(or); // eslint-disable-line ramda/complement-simplification
-
-export default nor;

package/src/notAllPass.js

@@ -1,32 +0,0 @@
-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
- */
-const notAllPass = curry(compose(complement, allPass));
-
-export default notAllPass;

package/src/notAllUnique.js

@@ -1,25 +0,0 @@
-import { complement } from 'ramda';
-
-import allUnique from './allUnique.js';
-
-/**
- * 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
- *
- */
-const notAllUnique = complement(allUnique);
-
-export default notAllUnique;

package/src/notBoth.js

@@ -1,38 +0,0 @@
-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 */
-const notBoth = curry(compose(complement, both));
-
-export default notBoth;

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,30 +0,0 @@
-import { pipe, isNotEmpty, intersection, isEmpty, curryN } from 'ramda';
-
-/**
- * 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.js';
-import isFunction from './isFunction.js';
-
-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.js';
-import ponyfill from './internal/ponyfills/String.padStart.js';
-
-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.js';
-
-/**
- * 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.js';
-
-/**
- * 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;