ramda-adjunct 5.0.0 → 5.0.1

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;

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;