ramda-adjunct 2.34.0

package/es/lengthLte.js

@@ -0,0 +1,23 @@
+import { flip, lte } from 'ramda';
+import compareLength from './internal/compareLength';
+/**
+ * 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
+ */
+
+var lengthLte = compareLength(flip(lte));
+export default lengthLte;

package/es/lengthNotEq.js

@@ -0,0 +1,22 @@
+import { complement, equals } from 'ramda';
+import compareLength from './internal/compareLength';
+/**
+ * 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
+ */
+
+var lengthNotEq = compareLength(complement(equals));
+export default lengthNotEq;

package/es/lensEq.js

@@ -0,0 +1,27 @@
+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
+ */
+
+var lensEq = curryN(3, function (lens, val, data) {
+  return pipe(view(lens), equals(val))(data);
+});
+export default lensEq;

package/es/lensIso.js

@@ -0,0 +1,55 @@
+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
+
+var isomorphic = function isomorphic(to, from) {
+  var isomorphism = function isomorphism(x) {
+    return to(x);
+  };
+
+  isomorphism.from = from;
+  return isomorphism;
+}; // isomorphisms :: ((a -> b), (b -> a)) -> (a -> b)
+
+
+var isomorphisms = function isomorphisms(to, from) {
+  return isomorphic(curry(function (toFunctorFn, target) {
+    return map(from, toFunctorFn(to(target)));
+  }), curry(function (toFunctorFn, target) {
+    return map(to, toFunctorFn(from(target)));
+  }));
+}; // from :: Isomorphism -> a -> b
+
+
+var from = curry(function (isomorphism, x) {
+  return 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 }
+ */
+
+var lensIso = curry(isomorphisms);
+lensIso.from = from;
+export default lensIso;

package/es/lensNotEq.js

@@ -0,0 +1,26 @@
+import { complement } from 'ramda';
+import lensEq from './lensEq';
+/**
+ * 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
+ */
+
+var lensNotEq = complement(lensEq);
+export default lensNotEq;

package/es/lensNotSatisfy.js

@@ -0,0 +1,28 @@
+import { complement } from 'ramda';
+import lensSatisfies from './lensSatisfies';
+/**
+ * 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
+ */
+
+var lensNotSatisfy = complement(lensSatisfies);
+export default lensNotSatisfy;

package/es/lensSatisfies.js

@@ -0,0 +1,31 @@
+import { view, curryN, pipe } from 'ramda';
+import isTrue from './isTrue';
+/**
+ * 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
+ */
+
+var lensSatisfies = curryN(3, function (predicate, lens, data) {
+  return pipe(view(lens), predicate, isTrue)(data);
+});
+export default lensSatisfies;

package/es/lensTraverse.js

@@ -0,0 +1,42 @@
+import { traverse, curry, pipe, prop, curryN } from 'ramda';
+import Identity from './fantasy-land/Identity';
+/**
+ * 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 Applicative f => (a -> f a) -> Lens s a
+ * @param {!function} of The Applicative-returning function
+ * @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])
+ */
+
+var lensTraverse = curryN(1, function (of) {
+  return curry(function (toFunctorFn, target) {
+    return Identity.of(traverse(of, pipe(toFunctorFn, prop('value')), target));
+  });
+});
+export default lensTraverse;

package/es/liftF.js

@@ -0,0 +1,37 @@
+import { curryN } from 'ramda';
+import liftFN from './liftFN';
+/**
+ * "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()
+ */
+
+var liftF = curryN(1, function (fn) {
+  return liftFN(fn.length, fn);
+});
+export default liftF;

package/es/liftFN.js

@@ -0,0 +1,47 @@
+import { curry, head, slice, reduce, curryN, map } from 'ramda';
+import ap from './internal/ap';
+/**
+ * "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()
+ */
+
+var liftFN = curry(function (arity, fn) {
+  var lifted = curryN(arity, fn);
+  return curryN(arity, function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    var accumulator = map(lifted, head(args));
+    var apps = slice(1, Infinity, args);
+    return reduce(ap, accumulator, apps);
+  });
+});
+export default liftFN;

package/es/list.js

@@ -0,0 +1,19 @@
+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']
+ */
+
+var list = unapply(identity);
+export default list;

package/es/mapIndexed.js

@@ -0,0 +1,26 @@
+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']
+ */
+
+var mapIndexed = addIndex(map);
+export default mapIndexed;

package/es/mergePath.js

@@ -0,0 +1,30 @@
+import { curry, over, lensPath } from 'ramda';
+import mergeRight from './mergeRight';
+/**
+ * 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 } }
+ */
+
+var mergePath = curry(function (path, source, obj) {
+  return over(lensPath(path), mergeRight(source), obj);
+});
+export default mergePath;

package/es/mergePaths.js

@@ -0,0 +1,27 @@
+import { curryN, pipe, mergeAll } from 'ramda';
+import paths from './paths';
+/**
+ * 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 }
+ */
+
+var mergePaths = curryN(2, pipe(paths, mergeAll));
+export default mergePaths;

package/es/mergeProp.js

@@ -0,0 +1,30 @@
+import { curry, of } from 'ramda';
+import mergePath from './mergePath';
+/**
+ * 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 } };
+ */
+
+var mergeProp = curry(function (p, subj, obj) {
+  return mergePath(of(p), subj, obj);
+});
+export default mergeProp;

package/es/mergeProps.js

@@ -0,0 +1,26 @@
+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 }
+ */
+
+var mergeProps = curryN(2, pipe(props, mergeAll));
+export default mergeProps;

package/es/mergeRight.js

@@ -0,0 +1,26 @@
+import { merge, flip } from 'ramda';
+/**
+ * Create a new object with the own properties of the second object merged with
+ * the own properties of the first object. If a key exists in both objects,
+ * the value from the first object will be used. *
+ * Putting it simply: it sets properties only if they don't exist.
+ *
+ * @func mergeRight
+ * @deprecated since v2.12.0; available in ramda@0.26.0 as R.mergeLeft
+ * @aliases mergeLeft, resetToDefault
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.6.0|v1.6.0}
+ * @category Object
+ * @sig {k: v} -> {k: v} -> {k: v}
+ * @param {Object} r Destination
+ * @param {Object} l Source
+ * @return {Object}
+ * @see {@link http://ramdajs.com/docs/#merge|R.merge}, {@link https://github.com/ramda/ramda/wiki/Cookbook#set-properties-only-if-they-dont-exist|Ramda Cookbook}
+ * @example
+ *
+ * RA.mergeRight({ 'age': 40 }, { 'name': 'fred', 'age': 10 });
+ * //=> { 'name': 'fred', 'age': 40 }
+ */
+
+var mergeRight = flip(merge);
+export default mergeRight;

package/es/move.js

@@ -0,0 +1,25 @@
+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']
+ */
+
+var move = curry(function (fromIdx, toIdx, list) {
+  return compose(insert(toIdx, nth(fromIdx, list)), remove(fromIdx, 1))(list);
+});
+export default move;

package/es/nand.js

@@ -0,0 +1,27 @@
+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
+ */
+
+var nand = complement(and); // eslint-disable-line ramda/complement-simplification
+
+export default nand;

package/es/neither.js

@@ -0,0 +1,39 @@
+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 */
+
+var neither = curry(compose(complement, either));
+export default neither;

package/es/noneP.js

@@ -0,0 +1,28 @@
+import { curryN, map, pipe } from 'ramda';
+import allP from './allP';
+import rejectP from './rejectP';
+import resolveP from './resolveP';
+/**
+ * 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')
+ */
+
+var noneP = curryN(1, pipe(map(resolveP), map(function (p) {
+  return p.then(rejectP, resolveP);
+}), allP));
+export default noneP;