ramda-adjunct 5.0.0 → 5.1.0

package/src/lastP.js

@@ -1,54 +0,0 @@
-import { bind, last, map, curryN } from 'ramda';
-
-import allP from './allP.js';
-import lengthEq from './lengthEq.js';
-import lengthGte from './lengthGte.js';
-import rejectP from './rejectP.js';
-import resolveP from './resolveP.js';
-
-/**
- * Returns a promise that is fulfilled by the last given promise to be fulfilled,
- * or rejected with an array of rejection reasons if all of the given promises are rejected.
- *
- * @func lastP
- * @memberOf RA
- * @category Function
- * @since {@link https://char0n.github.io/ramda-adjunct/2.23.0|v2.23.0}
- * @sig [Promise a] -> Promise a
- * @param {Iterable.<*>} iterable An iterable object such as an Array or String
- * @return {Promise} A promise that is fulfilled by the last given promise to be fulfilled, or rejected with an array of rejection reasons if all of the given promises are rejected.
- * @see {@link RA.anyP|anyP}
- * @example
- *
- * const delayP = timeout => new Promise(resolve => setTimeout(() => resolve(timeout), timeout));
- * delayP.reject = timeout => new Promise((resolve, reject) => setTimeout(() => reject(timeout), timeout));
- * RA.lastP([
- *   1,
- *   delayP(10),
- *   delayP(100),
- *   delayP.reject(1000),
- * ]); //=> Promise(100)
- */
-const lastP = curryN(1, (iterable) => {
-  const fulfilled = [];
-  const rejected = [];
-  const onFulfill = bind(fulfilled.push, fulfilled);
-  const onReject = bind(rejected.push, rejected);
-
-  const listOfPromises = map(
-    (p) => resolveP(p).then(onFulfill).catch(onReject),
-    [...iterable]
-  );
-
-  return allP(listOfPromises).then(() => {
-    if (lengthEq(0, fulfilled) && lengthEq(0, rejected)) {
-      return undefined;
-    }
-    if (lengthGte(1, fulfilled)) {
-      return last(fulfilled);
-    }
-    return rejectP(rejected);
-  });
-});
-
-export default lastP;

package/src/lengthEq.js

@@ -1,24 +0,0 @@
-import { equals } from 'ramda';
-
-import compareLength from './internal/compareLength.js';
-
-/**
- * Returns `true` if the supplied list or string has a length equal to `valueLength`.
- *
- * @func lengthEq
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.8.0|v2.8.0}
- * @category List
- * @sig Number -> [*] -> Boolean
- * @param {number} valueLength The length of the list or string
- * @param {Array|string} value The list or string
- * @return {boolean}
- * @see {@link RA.lengthNotEq|lengthNotEq}, {@link RA.lengthLt|lengthLt}, {@link RA.lengthGt|lengthGt}, {@link RA.lengthLte|lengthLte}, {@link RA.lengthGte|lengthGte},, {@link http://ramdajs.com/docs/#equals|equals}, {@link http://ramdajs.com/docs/#length|length}
- * @example
- *
- * RA.lengthEq(3, [1,2,3]); //=> true
- * RA.lengthEq(3, [1,2,3,4]); //=> false
- */
-const lengthEq = compareLength(equals);
-
-export default lengthEq;

package/src/lengthGt.js

@@ -1,24 +0,0 @@
-import { flip, gt } from 'ramda';
-
-import compareLength from './internal/compareLength.js';
-
-/**
- * Returns `true` if the supplied list or string has a length greater than `valueLength`.
- *
- * @func lengthGt
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.8.0|v2.8.0}
- * @category List
- * @sig Number -> [*] -> Boolean
- * @param {number} valueLength The length of the list or string
- * @param {Array|string} value The list or string
- * @return {boolean}
- * @see {@link RA.lengthEq|lengthEq}, {@link RA.lengthNotEq|lengthNotEq}, {@link RA.lengthLt|lengthLt}, {@link RA.lengthLte|lengthLte}, {@link RA.lengthGte|lengthGte}, {@link http://ramdajs.com/docs/#gt|gt},  {@link http://ramdajs.com/docs/#length|length}
- * @example
- *
- * RA.lengthGt(3, [1,2,3,4]); //=> true
- * RA.lengthGt(3, [1,2,3]); //=> false
- */
-const lengthGt = compareLength(flip(gt));
-
-export default lengthGt;

package/src/lengthGte.js

@@ -1,26 +0,0 @@
-import { flip, gte } from 'ramda';
-
-import compareLength from './internal/compareLength.js';
-
-/**
- * Returns `true` if the supplied list or string has a length greater than or equal to
- * `valueLength`.
- *
- * @func lengthGte
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.8.0|v2.8.0}
- * @category List
- * @sig Number -> [*] -> Boolean
- * @param {number} valueLength The length of the list or string
- * @param {Array|string} value The list or string
- * @return {boolean}
- * @see {@link RA.lengthEq|lengthEq}, {@link RA.lengthNotEq|lengthNotEq}, {@link RA.lengthLt|lengthLt}, {@link RA.lengthGt|lengthGt}, {@link RA.lengthLte|lengthLte}, {@link http://ramdajs.com/docs/#gte|gte}, {@link http://ramdajs.com/docs/#length|length}
- * @example
- *
- * RA.lengthGte(3, [1,2,3,4]); //=> true
- * RA.lengthGte(3, [1,2,3]); //=> true
- * RA.lengthGte(3, [1,2]); //=> false
- */
-const lengthGte = compareLength(flip(gte));
-
-export default lengthGte;

package/src/lengthLt.js

@@ -1,24 +0,0 @@
-import { flip, lt } from 'ramda';
-
-import compareLength from './internal/compareLength.js';
-
-/**
- * Returns `true` if the supplied list or string has a length less than `valueLength`.
- *
- * @func lengthLt
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.8.0|v2.8.0}
- * @category List
- * @sig Number -> [*] -> Boolean
- * @param {number} valueLength The length of the list or string
- * @param {Array|string} value The list or string
- * @return {boolean}
- * @see {@link RA.lengthEq|lengthEq}, {@link RA.lengthNotEq|lengthNotEq}, {@link RA.lengthGt|lengthGt}, {@link RA.lengthLte|lengthLte}, {@link RA.lengthGte|lengthGte}, {@link http://ramdajs.com/docs/#lt|lt}, {@link http://ramdajs.com/docs/#length|length}
- * @example
- *
- * RA.lengthLt(3, [1,2]); //=> true
- * RA.lengthLt(3, [1,2,3]); //=> false
- */
-const lengthLt = compareLength(flip(lt));
-
-export default lengthLt;

package/src/lengthLte.js

@@ -1,25 +0,0 @@
-import { flip, lte } from 'ramda';
-
-import compareLength from './internal/compareLength.js';
-
-/**
- * Returns `true` if the supplied list or string has a length less than or equal to `valueLength`.
- *
- * @func lengthLte
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.8.0|v2.8.0}
- * @category List
- * @sig Number -> [*] -> Boolean
- * @param {number} valueLength The length of the list or string
- * @param {Array|string} value The list or string
- * @return {boolean}
- * @see {@link RA.lengthEq|lengthEq}, {@link RA.lengthNotEq|lengthNotEq}, {@link RA.lengthLt|lengthLt}, {@link RA.lengthGt|lengthGt}, {@link RA.lengthGte|lengthGte}, {@link http://ramdajs.com/docs/#lte|lte}, {@link http://ramdajs.com/docs/#length|length}
- * @example
- *
- * RA.lengthLte(3, [1,2]); //=> true
- * RA.lengthLte(3, [1,2,3]); //=> true
- * RA.lengthLte(3, [1,2,3,4]); //=> false
- */
-const lengthLte = compareLength(flip(lte));
-
-export default lengthLte;

package/src/lengthNotEq.js

@@ -1,24 +0,0 @@
-import { complement, equals } from 'ramda';
-
-import compareLength from './internal/compareLength.js';
-
-/**
- * Returns `true` if the supplied list or string has a length not equal to `valueLength`.
- *
- * @func lengthNotEq
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.8.0|v2.8.0}
- * @category List
- * @sig Number -> [*] -> Boolean
- * @param {number} valueLength The length of the list or string
- * @param {Array|string} value The list or string
- * @return {boolean}
- * @see {@link RA.lengthEq|lengthEq}, {@link RA.lengthLt|lengthLt}, {@link RA.lengthGt|lengthGt}, {@link RA.lengthLte|lengthLte}, {@link RA.lengthGte|lengthGte}, {@link http://ramdajs.com/docs/#equals|equals}, {@link http://ramdajs.com/docs/#length|length}
- * @example
- *
- * RA.lengthNotEq(3, [1,2,3,4]); //=> true
- * RA.lengthNotEq(3, [1,2,3]); //=> false
- */
-const lengthNotEq = compareLength(complement(equals));
-
-export default lengthNotEq;

package/src/lensEq.js

@@ -1,28 +0,0 @@
-import { view, curryN, equals, pipe } from 'ramda';
-
-/**
- * Returns `true` if data structure focused by the given lens equals provided value.
- *
- * @func lensEq
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/1.13.0|1.13.0}
- * @category Relation
- * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s
- * @sig  Lens s a -> b -> s -> Boolean
- * @see {@link RA.lensNotEq|lensNotEq}
- * @param {function} lens Van Laarhoven lens
- * @param {*} value The value to compare the focused data structure with
- * @param {*} data The data structure
- * @return {boolean} `true` if the focused data structure equals value, `false` otherwise
- *
- * @example
- *
- * RA.lensEq(R.lensIndex(0), 1, [0, 1, 2]); // => false
- * RA.lensEq(R.lensIndex(1), 1, [0, 1, 2]); // => true
- * RA.lensEq(R.lensPath(['a', 'b']), 'foo', { a: { b: 'foo' } }) // => true
- */
-const lensEq = curryN(3, (lens, val, data) =>
-  pipe(view(lens), equals(val))(data)
-);
-
-export default lensEq;

package/src/lensIso.js

@@ -1,51 +0,0 @@
-import { curry, map } from 'ramda';
-
-// This implementation was highly inspired by the implementations
-// in ramda-lens library.
-//
-// https://github.com/ramda/ramda-lens
-
-// isomorphic :: ((a -> b), (b -> a)) -> Isomorphism
-//     Isomorphism = x -> y
-const isomorphic = (to, from) => {
-  const isomorphism = (x) => to(x);
-  isomorphism.from = from;
-  return isomorphism;
-};
-
-// isomorphisms :: ((a -> b), (b -> a)) -> (a -> b)
-const isomorphisms = (to, from) =>
-  isomorphic(
-    curry((toFunctorFn, target) => map(from, toFunctorFn(to(target)))),
-    curry((toFunctorFn, target) => map(to, toFunctorFn(from(target))))
-  );
-
-// from :: Isomorphism -> a -> b
-const from = curry((isomorphism, x) => isomorphism.from(x));
-
-/**
- * Defines an isomorphism that will work like a lens. It takes two functions.
- * The function that converts and the function that recovers.
- *
- * @func lensIso
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/1.19.0|1.19.0}
- * @category Relation
- * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s
- * @sig (s -> a) -> (a -> s) -> Lens s a
- * @param {!function} to The function that converts
- * @param {!function} from The function that recovers
- * @return {!function} The isomorphic lens
- * @see {@link http://ramdajs.com/docs/#lens|R.lens}
- *
- * @example
- *
- * const lensJSON = RA.lensIso(JSON.parse, JSON.stringify);
- *
- * R.over(lensJSON, assoc('b', 2), '{"a":1}'); //=> '{"a":1,"b":2}'
- * R.over(RA.lensIso.from(lensJSON), R.replace('}', ',"b":2}'), { a: 1 }); // => { a: 1, b: 2 }
- */
-const lensIso = curry(isomorphisms);
-lensIso.from = from;
-
-export default lensIso;

package/src/lensNotEq.js

@@ -1,28 +0,0 @@
-import { complement } from 'ramda';
-
-import lensEq from './lensEq.js';
-
-/**
- * Returns `true` if data structure focused by the given lens doesn't equal provided value.
- *
- * @func lensNotEq
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/1.13.0|1.13.0}
- * @category Relation
- * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s
- * @sig Lens s a -> b -> s -> Boolean
- * @see {@link RA.lensEq|lensEq}
- * @param {function} lens Van Laarhoven lens
- * @param {*} value The value to compare the focused data structure with
- * @param {*} data The data structure
- * @return {boolean} `false` if the focused data structure equals value, `true` otherwise
- *
- * @example
- *
- * RA.lensNotEq(R.lensIndex(0), 1, [0, 1, 2]); // => true
- * RA.lensNotEq(R.lensIndex(1), 1, [0, 1, 2]); // => false
- * RA.lensNotEq(R.lensPath(['a', 'b']), 'foo', { a: { b: 'foo' } }) // => false
- */
-const lensNotEq = complement(lensEq);
-
-export default lensNotEq;

package/src/lensNotSatisfy.js

@@ -1,30 +0,0 @@
-import { complement } from 'ramda';
-
-import lensSatisfies from './lensSatisfies.js';
-
-/**
- * Returns `true` if data structure focused by the given lens doesn't satisfy the predicate.
- * Note that the predicate is expected to return boolean value.
- *
- * @func lensNotSatisfy
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/1.13.0|1.13.0}
- * @category Relation
- * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s
- * @sig  Boolean b => (a -> b) -> Lens s a -> s -> b
- * @see {@link RA.lensSatisfies|lensSatisfies}
- * @param {Function} predicate The predicate function
- * @param {Function} lens Van Laarhoven lens
- * @param {*} data The data structure
- * @return {boolean} `false` if the focused data structure satisfies the predicate, `true` otherwise
- *
- * @example
- *
- * RA.lensNotSatisfy(RA.isTrue, R.lensIndex(0), [false, true, 1]); // => true
- * RA.lensNotSatisfy(RA.isTrue, R.lensIndex(1), [false, true, 1]); // => false
- * RA.lensNotSatisfy(RA.isTrue, R.lensIndex(2), [false, true, 1]); // => true
- * RA.lensNotSatisfy(R.identity, R.lensProp('x'), { x: 1 }); // => true
- */
-const lensNotSatisfy = complement(lensSatisfies);
-
-export default lensNotSatisfy;

package/src/lensSatisfies.js

@@ -1,33 +0,0 @@
-import { view, curryN, pipe } from 'ramda';
-
-import isTrue from './isTrue.js';
-
-/**
- * Returns `true` if data structure focused by the given lens satisfies the predicate.
- * Note that the predicate is expected to return boolean value and will be evaluated
- * as `false` unless the predicate returns `true`.
- *
- * @func lensSatisfies
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/1.13.0|1.13.0}
- * @category Relation
- * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s
- * @sig  Boolean b => (a -> b) -> Lens s a -> s -> b
- * @see {@link RA.lensNotSatisfy|lensNotSatisfy}
- * @param {Function} predicate The predicate function
- * @param {Function} lens Van Laarhoven lens
- * @param {*} data The data structure
- * @return {boolean} `true` if the focused data structure satisfies the predicate, `false` otherwise
- *
- * @example
- *
- * RA.lensSatisfies(RA.isTrue, R.lensIndex(0), [false, true, 1]); // => false
- * RA.lensSatisfies(RA.isTrue, R.lensIndex(1), [false, true, 1]); // => true
- * RA.lensSatisfies(RA.isTrue, R.lensIndex(2), [false, true, 1]); // => false
- * RA.lensSatisfies(R.identity, R.lensProp('x'), { x: 1 }); // => false
- */
-const lensSatisfies = curryN(3, (predicate, lens, data) =>
-  pipe(view(lens), predicate, isTrue)(data)
-);
-
-export default lensSatisfies;

package/src/lensTraverse.js

@@ -1,56 +0,0 @@
-import { traverse, curry, pipe, prop, curryN } from 'ramda';
-
-import Identity from './fantasy-land/Identity.js';
-
-/**
- * Creates a [Traversable](https://github.com/fantasyland/fantasy-land#traversable) lens
- * from an [Applicative](https://github.com/fantasyland/fantasy-land#applicative)-returning function.
- *
- * When executed, it maps an [Applicative](https://github.com/fantasyland/fantasy-land#applicative)-returning
- * function over a [Traversable](https://github.com/fantasyland/fantasy-land#traversable),
- * then uses [`sequence`](https://ramdajs.com/docs/#sequence) to transform the resulting Traversable of Applicative
- * into an Applicative of Traversable.
- *
- * Dispatches to the `traverse` method of the third argument, if present.
- *
- * @func lensTraverse
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.7.0|2.7.0}
- * @category Relation
- * @typedef Lens s a = Functor f => (a -> f a) -> s -> f s
- * @sig fantasy-land/of :: TypeRep f => f ~> a → f a
- * @sig Applicative f => (a -> f a) -> Lens s a
- * @sig Applicative f => TypeRep f -> Lens s a
- * @param {!Object|!Function} TypeRepresentative with an `of` or `fantasy-land/of` method
- * @return {!function} The Traversable lens
- * @see {@link http://ramdajs.com/docs/#lens|R.lens}, {@link http://ramdajs.com/docs/#traverse|R.traverse}
- *
- * @example
- *
- * const maybeLens = RA.lensTraverse(Maybe.of);
- * const safeDiv = n => d => d === 0 ? Maybe.Nothing() : Maybe.Just(n / d)
- *
- * R.over(maybeLens, safeDiv(10), [2, 4, 5]); // => Just([5, 2.5, 2])
- * R.over(maybeLens, safeDiv(10), [2, 0, 5]); // => Nothing
- *
- * R.view(maybeLens, [Maybe.Just(2), Maybe.Just(3)]); // => Maybe.Just([2, 3])
- *
- * R.set(maybeLens, Maybe.Just(1), [Maybe.just(2), Maybe.Just(3)]); // => Maybe.Just([1, 1])
- */
-/* eslint-disable no-nested-ternary */
-const lensTraverse = curryN(1, (F) => {
-  const of =
-    typeof F['fantasy-land/of'] === 'function'
-      ? F['fantasy-land/of']
-      : typeof F.of === 'function'
-        ? F.of
-        : F;
-  const TypeRep = { 'fantasy-land/of': of };
-
-  return curry((toFunctorFn, target) =>
-    Identity.of(traverse(TypeRep, pipe(toFunctorFn, prop('value')), target))
-  );
-});
-/* eslint-enable */
-
-export default lensTraverse;

package/src/liftF.js

@@ -1,37 +0,0 @@
-import { curryN } from 'ramda';
-
-import liftFN from './liftFN.js';
-
-/**
- * "lifts" a function to be the specified arity, so that it may "map over" objects that satisfy
- * the fantasy land Apply spec of algebraic structures.
- *
- * Lifting is specific for {@link https://github.com/scalaz/scalaz|scalaz} and {@link http://functionaljava.org/|function Java} implementations.
- * Old version of fantasy land spec were not compatible with this approach,
- * but as of fantasy land 1.0.0 Apply spec also adopted this approach.
- *
- * This function acts as interop for ramda <= 0.23.0 and {@link https://monet.github.io/monet.js/|monet.js}.
- *
- * More info {@link https://github.com/fantasyland/fantasy-land/issues/50|here}.
- *
- * @func liftF
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/1.2.0|v1.2.0}
- * @category Function
- * @sig Apply a => (a... -> a) -> (a... -> a)
- * @param {Function} fn The function to lift into higher context
- * @return {Function} The lifted function
- * @see {@link RA.liftFN|liftFN}
- * @example
- *
- * const { Maybe } = require('monet');
- *
- * const add3 = (a, b, c) => a + b + c;
- * const madd3 = RA.liftF(add3);
- *
- * madd3(Maybe.Some(10), Maybe.Some(15), Maybe.Some(17)); //=> Maybe.Some(42)
- * madd3(Maybe.Some(10), Maybe.Nothing(), Maybe.Some(17)); //=> Maybe.Nothing()
- */
-const liftF = curryN(1, (fn) => liftFN(fn.length, fn));
-
-export default liftF;

package/src/liftFN.js

@@ -1,45 +0,0 @@
-import { curry, head, slice, reduce, curryN, map } from 'ramda';
-
-import ap from './internal/ap.js';
-
-/**
- * "lifts" a function to be the specified arity, so that it may "map over" objects that satisfy
- * the fantasy land Apply spec of algebraic structures.
- *
- * Lifting is specific for {@link https://github.com/scalaz/scalaz|scalaz} and {@link http://www.functionaljava.org/|functional java} implementations.
- * Old version of fantasy land spec were not compatible with this approach,
- * but as of fantasy land 1.0.0 Apply spec also adopted this approach.
- *
- * This function acts as interop for ramda <= 0.23.0 and {@link https://monet.github.io/monet.js/|monet.js}.
- *
- * More info {@link https://github.com/fantasyland/fantasy-land/issues/50|here}.
- *
- * @func liftFN
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/1.2.0|v1.2.0}
- * @category Function
- * @sig Apply a => Number -> (a... -> a) -> (a... -> a)
- * @param {number} arity The arity of the lifter function
- * @param {Function} fn The function to lift into higher context
- * @return {Function} The lifted function
- * @see {@link http://ramdajs.com/docs/#lift|R.lift}, {@link http://ramdajs.com/docs/#ap|R.ap}
- * @example
- *
- * const { Maybe } = require('monet');
- *
- * const add3 = (a, b, c) => a + b + c;
- * const madd3 = RA.liftFN(3, add3);
- *
- * madd3(Maybe.Some(10), Maybe.Some(15), Maybe.Some(17)); //=> Maybe.Some(42)
- * madd3(Maybe.Some(10), Maybe.Nothing(), Maybe.Some(17)); //=> Maybe.Nothing()
- */
-const liftFN = curry((arity, fn) => {
-  const lifted = curryN(arity, fn);
-  return curryN(arity, (...args) => {
-    const accumulator = map(lifted, head(args));
-    const apps = slice(1, Infinity, args);
-    return reduce(ap, accumulator, apps);
-  });
-});
-
-export default liftFN;

package/src/list.js

@@ -1,20 +0,0 @@
-import { unapply, identity } from 'ramda';
-
-/**
- * Creates a list from arguments.
- *
- * @func list
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/1.1.0|v1.1.0}
- * @category List
- * @sig  a... -> [a...]
- * @param {...*} items The items of the feature list
- * @return {Array} New list created from items
- * @see {@link https://github.com/ramda/ramda/wiki/Cookbook#create-a-list-function|Ramda Cookbook}
- * @example
- *
- * RA.list('a', 'b', 'c'); //=> ['a', 'b', 'c']
- */
-const list = unapply(identity);
-
-export default list;

package/src/mapIndexed.js

@@ -1,27 +0,0 @@
-import { addIndex, map } from 'ramda';
-
-/**
- * {@link http://ramdajs.com/docs/#map|R.map} function that more closely resembles Array.prototype.map.
- * It takes two new parameters to its callback function: the current index, and the entire list.
- *
- * `mapIndexed` implementation is simple : `
- * const mapIndexed = R.addIndex(R.map);
- * `
- * @func mapIndexed
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.5.0|v2.5.0}
- * @category List
- * @typedef Idx = Number
- * @sig Functor f => ((a, Idx, 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 {@link http://ramdajs.com/docs/#addIndex|R.addIndex}, {@link http://ramdajs.com/docs/#map|R.map}
- * @example
- *
- * RA.mapIndexed((val, idx, list) => idx + '-' + val, ['f', 'o', 'o', 'b', 'a', 'r']);
- * //=> ['0-f', '1-o', '2-o', '3-b', '4-a', '5-r']
- */
-const mapIndexed = addIndex(map);
-
-export default mapIndexed;

package/src/mergePath.js

@@ -1,30 +0,0 @@
-import { curry, over, lensPath, mergeLeft } from 'ramda';
-
-/**
- * Create a new object with the own properties of the object under the `path`
- * merged with the own properties of the provided `source`.
- * If a key exists in both objects, the value from the `source` object will be used.
- *
- * @func mergePath
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/1.18.0|v1.18.0}
- * @category Object
- * @sig [k] -> {a} -> {k: {a}} -> {k: {a}}
- * @see {@link RA.mergeProp|mergeProp}
- * @param {!Array} path The property path of the destination object
- * @param {!Object} source The source object
- * @param {!Object} obj The object that has destination object under corresponding property path
- * @return {!Object} The new version of object
- * @example
- *
- * RA.mergePath(
- *  ['outer', 'inner'],
- *  { foo: 3, bar: 4 },
- *  { outer: { inner: { foo: 2 } } }
- * ); //=> { outer: { inner: { foo: 3, bar: 4 } }
- */
-const mergePath = curry((path, source, obj) =>
-  over(lensPath(path), mergeLeft(source), obj)
-);
-
-export default mergePath;

package/src/mergePaths.js

@@ -1,29 +0,0 @@
-import { curryN, pipe, mergeAll } from 'ramda';
-
-import paths from './paths.js';
-
-/**
- * Merge objects under corresponding paths.
- *
- * @func mergePaths
- * @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.mergeProps|mergeProps}
- * @param {!Array} paths The property paths to merge
- * @param {!Object} obj The object to query
- * @return {!Object} The object composed of merged property paths of obj
- * @example
- *
- * const obj = {
- *   foo: { fooInner: { fooInner2: 1 } },
- *   bar: { barInner: 2 }
- * };
- *
- * { ...obj.foo.fooInner, ...obj.bar }; //=>  { fooInner2: 1, barInner: 2 }
- * RA.mergePaths([['foo', 'fooInner'], ['bar']], obj); //=> { fooInner2: 1, barInner: 2 }
- */
-const mergePaths = curryN(2, pipe(paths, mergeAll));
-
-export default mergePaths;

package/src/mergeProp.js

@@ -1,30 +0,0 @@
-import { curry, of } from 'ramda';
-
-import mergePath from './mergePath.js';
-
-/**
- * Create a new object with the own properties of the object under the `p`
- * merged with the own properties of the provided `source`.
- * If a key exists in both objects, the value from the `source` object will be used.
- *
- * @func mergeProp
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/1.18.0|v1.18.0}
- * @category Object
- * @sig [k] -> {a} -> {k: {a}} -> {k: {a}}
- * @see {@link RA.mergePath|mergePath}
- * @param {!Array} p The property of the destination object
- * @param {!Object} source The source object
- * @param {!Object} obj The object that has destination object under corresponding property
- * @return {!Object} The new version of object
- * @example
- *
- * RA.mergeProp(
- *  'outer',
- *  { foo: 3, bar: 4 },
- *  { outer: { foo: 2 } }
- * ); //=> { outer: { foo: 3, bar: 4 } };
- */
-const mergeProp = curry((p, subj, obj) => mergePath(of(Array, p), subj, obj));
-
-export default mergeProp;