ramda-adjunct 5.0.0 → 5.1.0

package/src/fantasy-land/Identity.js

@@ -1,270 +0,0 @@
-import { empty as emptyR } from 'ramda';
-
-import * as fl from './mapping.js';
-import {
-  applyTrait,
-  functorTrait,
-  setoidTrait,
-  semigroupTrait,
-  chainTrait,
-  ordTrait,
-} from './traits.js';
-
-/**
- * The simplest {@link https://github.com/fantasyland/fantasy-land|fantasy-land}
- * compatible monad which attaches no information to values.
- *
- * The Identity type is a very simple type that has no interesting side effects and
- * is effectively just a container of some value. So why does it exist ?
- * The Identity type is often used as the base monad of a monad
- * transformer when no other behaviour is required.
- *
- * @memberOf RA
- * @implements
- * {@link https://github.com/fantasyland/fantasy-land#apply|Apply},
- * {@link https://github.com/fantasyland/fantasy-land#applicative|Applicative},
- * {@link https://github.com/fantasyland/fantasy-land#functor|Functor},
- * {@link https://github.com/fantasyland/fantasy-land#setoid|Setoid},
- * {@link https://github.com/fantasyland/fantasy-land#semigroup|Semigroup},
- * {@link https://github.com/fantasyland/fantasy-land#chain|Chain},
- * {@link https://github.com/fantasyland/fantasy-land#monad|Monad},
- * {@link https://github.com/fantasyland/fantasy-land#ord|Ord},
- * {@link https://github.com/fantasyland/fantasy-land#monoid|Monoid*},
- * {@link https://github.com/fantasyland/fantasy-land#contravariant|Contravariant}
- * @since {@link https://char0n.github.io/ramda-adjunct/1.8.0|v1.8.0}
- */
-class Identity {
-  /**
-   * Fantasy land {@link https://github.com/fantasyland/fantasy-land#applicative|Applicative} specification.
-   *
-   * @static
-   * @sig of :: Applicative f => a -> f a
-   * @param {*} value
-   * @returns {RA.Identity}
-   * @example
-   *
-   * const a = Identity.of(1); //=> Identity(1)
-   */
-  static [fl.of](value) {
-    return new Identity(value);
-  }
-
-  static of(value) {
-    return new Identity(value);
-  }
-
-  /**
-   * @static
-   */
-  static get ['@@type']() {
-    return 'RA/Identity';
-  }
-
-  /**
-   * Private constructor. Use {@link RA.Identity.of|Identity.of} instead.
-   *
-   * @param {*} value
-   * @return {RA.Identity}
-   */
-  constructor(value) {
-    this.value = value;
-  }
-
-  /**
-   * Catamorphism for a value.
-   * @returns {*}
-   * @example
-   *
-   * const a = Identity.of(1);
-   * a.get(); //=> 1
-   */
-  get() {
-    return this.value;
-  }
-
-  /**
-   * Fantasy land {@link https://github.com/fantasyland/fantasy-land#apply|Apply} specification.
-   *
-   * @sig ap :: Apply f => f a ~> f (a -> b) -> f b
-   * @param {RA.Identity} applyWithFn
-   * @return {RA.Identity}
-   * @example
-   *
-   * const a = Identity.of(1);
-   * const b = Identity.of(1).map(a => b => a + b);
-   *
-   * a.ap(b); //=> Identity(2)
-   */
-  [fl.ap](applyWithFn) {
-    return applyTrait[fl.ap].call(this, applyWithFn);
-  }
-
-  ap(applyWithFn) {
-    return this[fl.ap](applyWithFn);
-  }
-
-  /**
-   * Fantasy land {@link https://github.com/fantasyland/fantasy-land#functor|Functor} specification.
-   *
-   * @sig map :: Functor f => f a ~> (a -> b) -> f b
-   * @param {Function} fn
-   * @return {RA.Identity}
-   * @example
-   *
-   * const a = Identity.of(1);
-   * a.map(a => a + 1); //=> Identity(2)
-   */
-  [fl.map](fn) {
-    return functorTrait[fl.map].call(this, fn);
-  }
-
-  map(fn) {
-    return this[fl.map](fn);
-  }
-
-  /**
-   * Fantasy land {@link https://github.com/fantasyland/fantasy-land#setoid|Setoid} specification.
-   *
-   * @sig equals :: Setoid a => a ~> a -> Boolean
-   * @param {RA.Identity} setoid
-   * @return {boolean}
-   * @example
-   *
-   * const a = Identity.of(1);
-   * const b = Identity.of(1);
-   * const c = Identity.of(2);
-   *
-   * a.equals(b); //=> true
-   * a.equals(c); //=> false
-   */
-  [fl.equals](setoid) {
-    return setoidTrait[fl.equals].call(this, setoid);
-  }
-
-  equals(setoid) {
-    return this[fl.equals](setoid);
-  }
-
-  /**
-   * Fantasy land {@link https://github.com/fantasyland/fantasy-land#semigroup|Semigroup} specification.
-   *
-   * @sig concat :: Semigroup a => a ~> a -> a
-   * @param {RA.Identity} semigroup
-   * @return {RA.Identity}
-   * @example
-   *
-   * const a = Identity.of(1);
-   * const b = Identity.of(1);
-   * a.concat(b); //=> 2
-   *
-   * const c = Identity.of('c');
-   * const d = Identity.of('d');
-   * c.concat(d); //=> 'cd'
-   *
-   * const e = Identity.of(['e']);
-   * const f = Identity.of(['f']);
-   * e.concat(f); //=> ['e', 'f']
-   */
-  [fl.concat](semigroup) {
-    return semigroupTrait[fl.concat].call(this, semigroup);
-  }
-
-  concat(semigroup) {
-    return this[fl.concat](semigroup);
-  }
-
-  /**
-   * Fantasy land {@link https://github.com/fantasyland/fantasy-land#chain|Chain} specification.
-   *
-   * @sig chain :: Chain m => m a ~> (a -> m b) -> m b
-   * @param {Function} fn Function returning the value of the same {@link https://github.com/fantasyland/fantasy-land#semigroup|Chain}
-   * @return {RA.Identity}
-   * @example
-   *
-   * const a = Identity.of(1);
-   * const fn = val => Identity.of(val + 1);
-   *
-   * a.chain(fn).chain(fn); //=> Identity(3)
-   */
-  [fl.chain](fn) {
-    return chainTrait[fl.chain].call(this, fn);
-  }
-
-  chain(fn) {
-    return this[fl.chain](fn);
-  }
-
-  /**
-   * Fantasy land {@link https://github.com/fantasyland/fantasy-land#ord|Ord} specification.
-   *
-   * @sig lte :: Ord a => a ~> a -> Boolean
-   * @param {RA.Identity} ord
-   * @return {boolean}
-   * @example
-   *
-   * const a = Identity.of(1);
-   * const b = Identity.of(1);
-   * const c = Identity.of(2);
-   *
-   * a.lte(b); //=> true
-   * a.lte(c); //=> true
-   * c.lte(a); //=> false
-   */
-  [fl.lte](ord) {
-    return ordTrait[fl.lte].call(this, ord);
-  }
-
-  lte(ord) {
-    return this[fl.lte](ord);
-  }
-
-  /**
-   * Fantasy land {@link https://github.com/fantasyland/fantasy-land#monoid|Monoid*} specification.
-   * Partial implementation of Monoid specification. `empty` method on instance only, returning
-   * identity value of the wrapped type. Using `R.empty` under the hood.
-   *
-   *
-   * @sig empty :: Monoid m => () -> m
-   * @return {RA.Identity}
-   * @example
-   *
-   * const a = Identity.of('test');
-   * const i = a.empty();
-   *
-   * a.concat(i); //=> Identity('string');
-   * i.concat(a); //=> Identity('string');
-   */
-  [fl.empty]() {
-    return this.constructor.of(emptyR(this.value));
-  }
-
-  empty() {
-    return this[fl.empty]();
-  }
-
-  /**
-   * Fantasy land {@link https://github.com/fantasyland/fantasy-land#contravariant|Contravariant} specification.
-   *
-   * @sig contramap :: Contravariant f => f a ~> (b -> a) -> f b
-   * @param {Function} fn
-   * @return {RA.Identity}
-   * @example
-   *
-   * const identity = a => a;
-   * const add1 = a => a + 1;
-   * const divide2 = a => a / 2;
-   *
-   * Identity.of(divide2).contramap(add1).get()(3); //=> 2
-   * Identity.of(identity).contramap(divide2).contramap(add1).get()(3); //=> 2
-   * Identity.of(identity).contramap(a => divide2(add1(a))).get()(3); //=> 2
-   */
-  [fl.contramap](fn) {
-    return this.constructor.of((value) => this.value(fn(value)));
-  }
-
-  contramap(fn) {
-    return this[fl.contramap](fn);
-  }
-}
-
-export default Identity;

package/src/fantasy-land/mapping.js

@@ -1,20 +0,0 @@
-export const equals = 'fantasy-land/equals';
-export const lte = 'fantasy-land/lte';
-export const compose = 'fantasy-land/compose';
-export const id = 'fantasy-land/id';
-export const concat = 'fantasy-land/concat';
-export const empty = 'fantasy-land/empty';
-export const map = 'fantasy-land/map';
-export const contramap = 'fantasy-land/contramap';
-export const ap = 'fantasy-land/ap';
-export const of = 'fantasy-land/of';
-export const alt = 'fantasy-land/alt';
-export const zero = 'fantasy-land/zero';
-export const reduce = 'fantasy-land/reduce';
-export const traverse = 'fantasy-land/traverse';
-export const chain = 'fantasy-land/chain';
-export const chainRec = 'fantasy-land/chainRec';
-export const extend = 'fantasy-land/extend';
-export const extract = 'fantasy-land/extract';
-export const bimap = 'fantasy-land/bimap';
-export const promap = 'fantasy-land/promap';

package/src/fantasy-land/traits.js

@@ -1,57 +0,0 @@
-import { equals, pathSatisfies } from 'ramda';
-
-import isString from '../isString.js';
-import isNumber from '../isNumber.js';
-import isFunction from '../isFunction.js';
-import { isSameType } from './util.js';
-import * as fl from './mapping.js';
-
-export const functorTrait = {
-  [fl.map](fn) {
-    return this.constructor[fl.of](fn(this.value));
-  },
-};
-
-export const applyTrait = {
-  [fl.ap](applyWithFn) {
-    return applyWithFn.map((fn) => fn(this.value));
-  },
-};
-
-export const setoidTrait = {
-  [fl.equals](setoid) {
-    return isSameType(this, setoid) && equals(this.value, setoid.value);
-  },
-};
-
-export const semigroupTrait = {
-  [fl.concat](semigroup) {
-    let concatenatedValue = this.value;
-
-    if (isString(this.value) || isNumber(this.value)) {
-      concatenatedValue = this.value + semigroup.value;
-    } else if (pathSatisfies(isFunction, ['value', fl.concat], this)) {
-      concatenatedValue = this.value[fl.concat](semigroup.value);
-    } else if (pathSatisfies(isFunction, ['value', 'concat'], this)) {
-      concatenatedValue = this.value.concat(semigroup.value);
-    }
-
-    return this.constructor[fl.of](concatenatedValue);
-  },
-};
-
-export const chainTrait = {
-  [fl.chain](fn) {
-    const newChain = fn(this.value);
-
-    return isSameType(this, newChain) ? newChain : this;
-  },
-};
-
-export const ordTrait = {
-  [fl.lte](ord) {
-    return (
-      isSameType(this, ord) && (this.value < ord.value || this[fl.equals](ord))
-    );
-  },
-};

package/src/fantasy-land/util.js

@@ -1,23 +0,0 @@
-import {
-  useWith,
-  curry,
-  curryN,
-  equals,
-  path,
-  either,
-  complement,
-} from 'ramda';
-
-// type :: Monad a => a -> String
-export const type = either(path(['@@type']), path(['constructor', '@@type']));
-
-// typeEquals :: Monad a => String -> a -> Boolean
-export const typeEquals = curry(
-  (typeIdent, monad) => type(monad) === typeIdent
-);
-
-// isSameType :: (Monad a, Monad b) => a -> b -> Boolean
-export const isSameType = curryN(2, useWith(equals, [type, type]));
-
-// isNotSameType :: (Monad a, Monad b) => a -> b -> Boolean
-export const isNotSameType = complement(isSameType);

package/src/filterIndexed.js

@@ -1,28 +0,0 @@
-import { addIndex, filter } from 'ramda';
-
-/**
- * {@link http://ramdajs.com/docs/#filter|R.filter} function that more closely resembles `Array.prototype.filter`.
- * It takes two new parameters to its callback function: the current index, and the entire list.
- *
- * `filterIndexed` implementation is simple: `
- *  const filterIndexed = R.addIndex(R.filter);
- * `
- *
- * @func filterIndexed
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.31.0|v2.31.0}
- * @category List
- * @typedef Idx = Number
- * @sig Filterable f => ((a, Idx, f a) -> Boolean) -> f a -> f a
- * @param {Function} pred The predicate function
- * @param {Array} list The collection to filter
- * @return {Array} Filterable
- * @see {@link http://ramdajs.com/docs/#addIndex|R.addIndex}, {@link http://ramdajs.com/docs/#filter|R.filter}
- * @example
- *
- * const isValueGtIndex = (val, idx) => val > idx;
- * RA.filterIndexed(isValueGtIndex, [5, 4, 3, 2, 1, 0]); //=> [5, 4, 3]
- */
-const filterIndexed = addIndex(filter);
-
-export default filterIndexed;

package/src/findOr.js

@@ -1,30 +0,0 @@
-import { pipe, curry, find, defaultTo } from 'ramda';
-
-/**
- * Returns the first element of the list which matches the predicate.
- * Returns default value if no element matches or matched element is `null`, `undefined` or `NaN`.
- * Dispatches to the find method of the second argument, if present.
- * Acts as a transducer if a transformer is given in list position.
- *
- * @func findOr
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.32.0|v2.32.0}
- * @category List
- * @sig  a -> (b -> Boolean) -> [b] -> b | a
- * @param {*} defaultValue The default value
- * @param {Function} fn The predicate function used to determine if the element is the desired one.
- * @param {Array} list The array to consider.
- * @return {*} The element found, or the default value.
- * @see {@link http://ramdajs.com/docs/#defaultTo|R.defaultTo}, {@link http://ramdajs.com/docs/#find|R.find}
- * @example
- *
- * RA.findOr(1, isUndefined, [1, 2, undefined]); // => 1
- * RA.findOr(1, val => val === 2, [1, 2, undefined]); // => 2
- * RA.findOr(1, val => val === 3, [1, 2, undefined]); // => 1
- */
-
-const findOr = curry((defaultVal, fn, list) =>
-  pipe(find(fn), defaultTo(defaultVal))(list)
-);
-
-export default findOr;

package/src/flattenDepth.js

@@ -1,39 +0,0 @@
-import { curry } from 'ramda';
-
-import _makeFlat from './internal/makeFlat.js';
-
-const flatten1 = _makeFlat(false);
-
-/**
- * Flattens the list to the specified depth.
- *
- * @func flattenDepth
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.19.0|v2.19.0}
- * @category List
- * @sig Number -> [a] -> [b]
- * @param {!number} depth The maximum recursion depth
- * @param {!Array} list The array to flatten
- * @return {!Array} Returns the new flattened array
- * @see {@link http://ramdajs.com/docs/#flatten|R.flatten}, {@link http://ramdajs.com/docs/#unnest|R.unnest}
- * @example
- *
- * RA.flattenDepth(
- *   2,
- *   [1, [2], [3, [4, 5], 6, [[[7], 8]]], 9, 10]
- * ); //=> [1, 2, 3, 4, 5, 6, [[7], 8], 9, 10];
- */
-const flattenDepth = curry((depth, list) => {
-  let currentDept = depth;
-  let flatList = [...list];
-
-  while (currentDept > 0) {
-    flatList = flatten1(flatList);
-
-    currentDept -= 1;
-  }
-
-  return flatList;
-});
-
-export default flattenDepth;

package/src/flattenPath.js

@@ -1,28 +0,0 @@
-import { pathOr, curry, mergeRight } from 'ramda';
-
-/**
- * Flattens a property path so that its fields are spread out into the provided object.
- * It's like {@link RA.spreadPath|spreadPath}, but preserves object under the property path.
- *
- * @func flattenPath
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/1.19.0|v1.19.0}
- * @category Object
- * @typedef Idx = String | Int
- * @sig [Idx] -> {k: v} -> {k: v}
- * @param {!Array.<string|number>} path The property path to flatten
- * @param {!Object} obj The provided object
- * @return {!Object} The flattened object
- * @see {@link RA.flattenProp|flattenProp}, {@link RA.spreadPath|spreadPath}
- * @example
- *
- * RA.flattenPath(
- *   ['b1', 'b2'],
- *   { a: 1, b1: { b2: { c: 3, d: 4 } } }
- * ); // => { a: 1, c: 3, d: 4, b1: { b2: { c: 3, d: 4 } } };
- */
-const flattenPath = curry((path, obj) =>
-  mergeRight(obj, pathOr({}, path, obj))
-);
-
-export default flattenPath;

package/src/flattenProp.js

@@ -1,28 +0,0 @@
-import { of, curry } from 'ramda';
-
-import flattenPath from './flattenPath.js';
-
-/**
- * Flattens a property so that its fields are spread out into the provided object.
- * It's like {@link RA.spreadProp|spreadProp}, but preserves object under the property path.
- *
- * @func flattenProp
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/1.19.0|v1.19.0}
- * @category Object
- * @typedef Idx = String | Int
- * @sig [Idx] -> {k: v} -> {k: v}
- * @param {!string|number} prop The property to flatten
- * @param {!Object} obj The provided object
- * @return {!Object} The flattened object
- * @see {@link RA.flattenPath|flattenPath}, {@link RA.spreadProp|spreadProp}
- * @example
- *
- * RA.flattenProp(
- *   'b',
- *   { a: 1, b: { c: 3, d: 4 } }
- * ); // => { a: 1, c: 3, d: 4, b: { c: 3, d: 4 } };
- */
-const flattenProp = curry((prop, obj) => flattenPath(of(Array, prop), obj));
-
-export default flattenProp;

package/src/floor.js

@@ -1,27 +0,0 @@
-import { bind, curryN } from 'ramda';
-
-/**
- * Returns the largest integer less than or equal to a given number.
- *
- * Note: floor(null) returns integer 0 and do not give a NaN error.
- *
- * @func floor
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.15.0|v2.15.0}
- * @category Math
- * @sig Number -> Number
- * @param {number} number The number to floor
- * @return {number} A number representing the largest integer less than or equal to the specified number
- * @example
- *
- * RA.floor(45.95); //=> 45
- * RA.floor(45.05); //=> 45
- * RA.floor(4); //=> 4
- * RA.floor(-45.05); //=> -46
- * RA.floor(-45.95); //=> -46
- * RA.floor(null); //=> 0
- */
-
-const floor = curryN(1, bind(Math.floor, Math));
-
-export default floor;

package/src/fnull.js

@@ -1,38 +0,0 @@
-import { isNil, curryN, curry, apply } from 'ramda';
-
-import defaultWhen from './defaultWhen.js';
-import mapIndexed from './mapIndexed.js';
-
-/**
- * Returns a function which is called with the given arguments. If any of the given arguments are null or undefined,
- * the corresponding default value for that argument is used instead.
- *
- * @func fnull
- * @memberOf RA
- * @category Function
- * @sig (a ... -> b) -> [c] -> a ... | c -> b
- * @param {Function} function to be executed
- * @param {Array} defaults default arguments
- * @return {Function} will apply provided arguments or default ones
- * @example
- *
- * const addDefaults = RA.fnull((a, b) => a + b, [4, 5])
- *
- * addDefaults(1, 2); // => 3
- * addDefaults(null, 2); // => 6
- * addDefaults(2, null); // => 7
- * addDefaults(undefined, undefined); // => 9
- */
-
-const fnull = curry((fn, defaults) =>
-  curryN(fn.length, (...args) => {
-    const argsWithDefaults = mapIndexed(
-      (val, idx) => defaultWhen(isNil, defaults[idx], val),
-      args
-    );
-
-    return apply(fn, argsWithDefaults);
-  })
-);
-
-export default fnull;

package/src/inRange.js

@@ -1,34 +0,0 @@
-import { ifElse, curry, useWith, both, gte, lte, gt } from 'ramda';
-
-const inRangeImp = ifElse(
-  gte,
-  () => {
-    throw new Error(
-      'low must not be greater than high in inRange(low, high, value)'
-    );
-  },
-  useWith(both, [lte, gt])
-);
-
-/**
- * Checks if `value` is between `low` and up to but not including `high`.
- *
- * @func inRange
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.7.0|v2.7.0}
- * @category Relation
- * @sig Number -> Number -> Number -> Boolean
- * @param {number} low Start of the range
- * @param {number} high The end of the range
- * @param {number} value The value to test
- * @return {boolean}
- * @throws {Error} When `low` is greater than or equal to `high`
- * @example
- *
- * RA.inRange(0, 5, 3); //=> true
- * RA.inRange(0, 5, 0); //=> true
- * RA.inRange(0, 5, 4); //=> true
- * RA.inRange(0, 5, 5); //=> false
- * RA.inRange(0, 5, -1); //=> false
- */
-export default curry((low, high, value) => inRangeImp(low, high)(value));

package/src/included.js

@@ -1,28 +0,0 @@
-import { flip, includes } from 'ramda';
-
-/**
- * Returns true if the specified value is equal, in R.equals terms,
- * to at least one element of the given list or false otherwise.
- * Given list can be a string.
- *
- * Like {@link http://ramdajs.com/docs/#includes|R.includes} but with argument order reversed.
- *
- * @func included
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/3.0.0|v3.0.0}
- * @category List
- * @sig [a] -> a -> Boolean
- * @param {Array|String} list The list to consider
- * @param {*} a The item to compare against
- * @return {boolean} Returns Boolean `true` if an equivalent item is in the list or `false` otherwise
- * @see {@link http://ramdajs.com/docs/#includes|R.includes}
- * @example
- *
- * RA.included([1, 2, 3], 3); //=> true
- * RA.included([1, 2, 3], 4); //=> false
- * RA.included([{ name: 'Fred' }], { name: 'Fred' }); //=> true
- * RA.included([[42]], [42]); //=> true
- */
-const included = flip(includes);
-
-export default included;