ramda-adjunct 5.0.0 → 5.1.0

package/src/pickIndexes.js

@@ -1,30 +0,0 @@
-import { filter, addIndex, curry, includes } from 'ramda';
-
-// helpers
-const filterIndexed = addIndex(filter);
-const containsIndex = curry((indexes, val, index) => includes(index, indexes));
-
-/**
- * Picks values from list by indexes.
- *
- * Note: pickIndexes will skip non existing indexes. If you want to include them
- * use ramda's `props` function.
- *
- * @func pickIndexes
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/1.1.0|v1.1.0}
- * @category List
- * @sig  [Number] -> [a] -> [a]
- * @param {Array} indexes The indexes to pick
- * @param {Array} list The list to pick values from
- * @return {Array} New array containing only values at `indexes`
- * @see {@link http://ramdajs.com/docs/#pick|R.pick}, {@link RA.omitIndexes|omitIndexes}
- * @example
- *
- * RA.pickIndexes([0, 2], ['a', 'b', 'c']); //=> ['a', 'c']
- */
-const pickIndexes = curry((indexes, list) =>
-  filterIndexed(containsIndex(indexes), list)
-);
-
-export default pickIndexes;

package/src/propNotEq.js

@@ -1,30 +0,0 @@
-import { propEq, complement } from 'ramda';
-
-/**
- * Returns true if the specified object property is not equal,
- * in R.equals terms, to the given value; false otherwise.
- *
- * @func propNotEq
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.3.0|v2.3.0}
- * @category Relation
- * @sig  a -> String -> Object -> Boolean
- * @param {a} val The value to compare to
- * @param {String} name The property to pick
- * @param {Object} object The object, that presumably contains value under the property
- * @return {boolean} Comparison result
- * @see {@link http://ramdajs.com/docs/#propEq|R.propEq}
- * @example
- *
- * const abby = { name: 'Abby', age: 7, hair: 'blond' };
- * const fred = { name: 'Fred', age: 12, hair: 'brown' };
- * const rusty = { name: 'Rusty', age: 10, hair: 'brown' };
- * const alois = { name: 'Alois', age: 15, disposition: 'surly' };
- * const kids = [abby, fred, rusty, alois];
- * const hasNotBrownHair = RA.propNotEq('brown', 'hair');
- *
- * R.filter(hasNotBrownHair, kids); //=> [abby, alois]
- */
-const propNotEq = complement(propEq);
-
-export default propNotEq;

package/src/rangeStep.js

@@ -1,37 +0,0 @@
-import { curryN, map, range, always } from 'ramda';
-
-import floor from './floor.js';
-
-/**
- * Creates an array of numbers (positive and/or negative) progressing from start up to, but not including, end.
- *
- * `Note`: JavaScript follows the IEEE-754 standard for resolving floating-point values which can produce unexpected results.
- *
- * @func rangeStep
- * @memberOf RA
- * @category List
- * @since {@link https://char0n.github.io/ramda-adjunct/2.30.0|v2.30.0}
- * @sig Number -> Number -> Number -> [Number]
- * @param {number} step The value to increment or decrement by
- * @param {number} from The start of the range
- * @param {number} to The end of the range
- * @return {number[]} Returns the range of numbers
- * @see {@link http://ramdajs.com/docs/#range|R.range}
- * @example
- *
- * RA.rangeStep(1, 0, 4); // => [0, 1 ,2, 3]
- * RA.rangeStep(-1, 0, -4); // => [0, -1, -2, -3]
- * RA.rangeStep(1, 1, 5); // => [1, 2, 3, 4]
- * RA.rangeStep(5, 0, 20); // => [0, 5, 10, 15]
- * RA.rangeStep(-1, 0, -4); // => [0, -1, -2, -3]
- * RA.rangeStep(0, 1, 4); // => [1, 1, 1]
- * RA.rangeStep(1, 0, 0); // => []
- */
-const rangeStep = curryN(3, (step, from, to) => {
-  const callback = step === 0 ? always(from) : (n) => from + step * n;
-  const rangeEnd = step === 0 ? to - from : floor((to - from) / step);
-
-  return map(callback, range(0, rangeEnd));
-});
-
-export default rangeStep;

package/src/reduceIndexed.js

@@ -1,31 +0,0 @@
-import { addIndex, reduce } from 'ramda';
-
-/**
- * {@link http://ramdajs.com/docs/#reduce|R.reduce} function that more closely resembles Array.prototype.reduce.
- * It takes two new parameters to its callback function: the current index, and the entire list.
- *
- * `reduceIndexed` implementation is simple : `
- * const reduceIndexed = R.addIndex(R.reduce);
- * `
- * @func reduceIndexed
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.5.0|v2.5.0}
- * @category List
- * @typedef Idx = Number
- * @sig ((a, b, Idx, [b]) => a) -> a -> [b] -> a
- * @param {Function} fn The iterator function. Receives four values,
- * the accumulator, the current element from the array, index and the entire list
- * @param {*} acc The accumulator value
- * @param {Array} list The list to iterate over
- * @return {*} The final, accumulated value
- * @see {@link http://ramdajs.com/docs/#addIndex|R.addIndex}, {@link http://ramdajs.com/docs/#reduce|R.reduce}
- * @example
- *
- * const initialList = ['f', 'o', 'o', 'b', 'a', 'r'];
- *
- * reduceIndexed((acc, val, idx, list) => acc + '-' + val + idx, '', initialList);
- * //=> "-f0-o1-o2-b3-a4-r5"
- */
-const reduceIndexed = addIndex(reduce);
-
-export default reduceIndexed;

package/src/reduceP.js

@@ -1,96 +0,0 @@
-import { curryN, reduce, length } from 'ramda';
-
-import isUndefined from './isUndefined.js';
-import resolveP from './resolveP.js';
-import allP from './allP.js';
-
-/* eslint-disable max-len */
-/**
- * Given an `Iterable`(arrays are `Iterable`), or a promise of an `Iterable`,
- * which produces promises (or a mix of promises and values),
- * iterate over all the values in the `Iterable` into an array and
- * reduce the array to a value using the given iterator function.
- *
- * If the iterator function returns a promise, then the result of the promise is awaited,
- * before continuing with next iteration. If any promise in the array is rejected or a promise
- * returned by the iterator function is rejected, the result is rejected as well.
- *
- * If `initialValue` is `undefined` (or a promise that resolves to `undefined`) and
- * the `Iterable` contains only 1 item, the callback will not be called and
- * the `Iterable's` single item is returned. If the `Iterable` is empty, the callback
- * will not be called and `initialValue` is returned (which may be undefined).
- *
- * This function is basically equivalent to {@link http://bluebirdjs.com/docs/api/promise.reduce.html|bluebird.reduce}.
- *
- * @func reduceP
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/1.13.0|v1.13.0}
- * @category List
- * @typedef MaybePromise = Promise.<*> | *
- * @sig ((Promise a, MaybePromise b) -> Promise a) -> MaybePromise a -> MaybePromise [MaybePromise b] -> Promise a
- * @param {Function} fn The iterator function. Receives two values, the accumulator and the current element from the list
- * @param {*|Promise.<*>} acc The accumulator value
- * @param {Array.<*>|Promise.<Array<*|Promise.<*>>>} list The list to iterate over
- * @return {Promise} The final, accumulated value
- * @see {@link http://ramdajs.com/docs/#reduce|R.reduce}, {@link RA.reduceRightP|reduceRightP}, {@link http://bluebirdjs.com/docs/api/promise.reduce.html|bluebird.reduce}
- * @example
- *
- * RA.reduceP(
- *   (total, fileName) => fs
- *     .readFileAsync(fileName, 'utf8')
- *     .then(contents => total + parseInt(contents, 10)),
- *   0,
- *   ['file1.txt', 'file2.txt', 'file3.txt']
- * ); // => Promise(10)
- *
- * RA.reduceP(
- *   (total, fileName) => fs
- *     .readFileAsync(fileName, 'utf8')
- *     .then(contents => total + parseInt(contents, 10)),
- *   Promise.resolve(0),
- *   ['file1.txt', 'file2.txt', 'file3.txt']
- * ); // => Promise(10)
- *
- * RA.reduceP(
- *   (total, fileName) => fs
- *     .readFileAsync(fileName, 'utf8')
- *     .then(contents => total + parseInt(contents, 10)),
- *   0,
- *   [Promise.resolve('file1.txt'), 'file2.txt', 'file3.txt']
- * ); // => Promise(10)
- *
- * RA.reduceP(
- *   (total, fileName) => fs
- *     .readFileAsync(fileName, 'utf8')
- *     .then(contents => total + parseInt(contents, 10)),
- *   0,
- *   Promise.resolve([Promise.resolve('file1.txt'), 'file2.txt', 'file3.txt'])
- * ); // => Promise(10)
- *
- */
-/* esline-enable max-len */
-const reduceP = curryN(3, (fn, acc, list) =>
-  resolveP(list).then((iterable) => {
-    const listLength = length(iterable);
-
-    if (listLength === 0) {
-      return acc;
-    }
-
-    const reducer = reduce((accP, currentValueP) =>
-      accP
-        .then((previousValue) => allP([previousValue, currentValueP]))
-        .then(([previousValue, currentValue]) => {
-          if (isUndefined(previousValue) && listLength === 1) {
-            return currentValue;
-          }
-
-          return fn(previousValue, currentValue);
-        })
-    );
-
-    return reducer(resolveP(acc), iterable);
-  })
-);
-
-export default reduceP;

package/src/reduceRightP.js

@@ -1,101 +0,0 @@
-import { curryN, pipe, equals, reduceRight, length, concat } from 'ramda';
-
-import isUndefined from './isUndefined.js';
-import resolveP from './resolveP.js';
-import allP from './allP.js';
-
-// in older ramda versions the order of the arguments is flipped
-const flipArgs = pipe(reduceRight(concat, ''), equals('ba'))(['a', 'b']);
-
-/* eslint-disable max-len */
-/**
- * Given an `Iterable`(arrays are `Iterable`), or a promise of an `Iterable`,
- * which produces promises (or a mix of promises and values),
- * iterate over all the values in the `Iterable` into an array and
- * reduce the array to a value using the given iterator function.
- *
- * Similar to {@link RA.reduceP|reduceP} except moves through the input list from the right to the left.
- * The iterator function receives two values: (value, acc),
- * while the arguments' order of reduceP's iterator function is (acc, value).
- *
- * @func reduceRightP
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/1.13.0|v1.13.0}
- * @category List
- * @typedef MaybePromise = Promise.<*> | *
- * @sig ((MaybePromise b, Promise a) -> Promise a) -> MaybePromise a -> MaybePromise [MaybePromise b] -> Promise a
- * @param {Function} fn The iterator function. Receives two values, the current element from the list and the accumulator
- * @param {*|Promise.<*>} acc The accumulator value
- * @param {Array.<*>|Promise.<Array<*|Promise.<*>>>} list The list to iterate over
- * @return {Promise} The final, accumulated value
- * @see {@link RA.reduceP|reduceP}, {@link http://bluebirdjs.com/docs/api/promise.reduce.html|bluebird.reduce}
- * @example
- *
- * RA.reduceRightP(
- *   (fileName, total) => fs
- *     .readFileAsync(fileName, 'utf8')
- *     .then(contents => total + parseInt(contents, 10)),
- *   0,
- *   ['file1.txt', 'file2.txt', 'file3.txt']
- * ); // => Promise(10)
- *
- * RA.reduceRightP(
- *   (fileName, total) => fs
- *     .readFileAsync(fileName, 'utf8')
- *     .then(contents => total + parseInt(contents, 10)),
- *   Promise.resolve(0),
- *   ['file1.txt', 'file2.txt', 'file3.txt']
- * ); // => Promise(10)
- *
- * RA.reduceRightP(
- *   (fileName, total) => fs
- *     .readFileAsync(fileName, 'utf8')
- *     .then(contents => total + parseInt(contents, 10)),
- *   0,
- *   [Promise.resolve('file1.txt'), 'file2.txt', 'file3.txt']
- * ); // => Promise(10)
- *
- * RA.reduceRightP(
- *   (fileName, total) => fs
- *     .readFileAsync(fileName, 'utf8')
- *     .then(contents => total + parseInt(contents, 10)),
- *   0,
- *   Promise.resolve([Promise.resolve('file1.txt'), 'file2.txt', 'file3.txt'])
- * ); // => Promise(10)
- *
- */
-/* esline-enable max-len */
-const reduceRightP = curryN(3, (fn, acc, list) =>
-  resolveP(list).then((iterable) => {
-    const listLength = length(iterable);
-
-    if (listLength === 0) {
-      return acc;
-    }
-
-    const reducer = reduceRight((arg1, arg2) => {
-      let accP;
-      let currentValueP;
-
-      if (flipArgs) {
-        [accP, currentValueP] = [arg1, arg2];
-      } else {
-        [accP, currentValueP] = [arg2, arg1];
-      }
-
-      return accP
-        .then((previousValue) => allP([previousValue, currentValueP]))
-        .then(([previousValue, currentValue]) => {
-          if (isUndefined(previousValue) && listLength === 1) {
-            return currentValue;
-          }
-
-          return fn(currentValue, previousValue);
-        });
-    });
-
-    return reducer(resolveP(acc), iterable);
-  })
-);
-
-export default reduceRightP;

package/src/rejectP.js

@@ -1,24 +0,0 @@
-import { bind } from 'ramda';
-
-/**
- * Composable shortcut for `Promise.reject`.
- *
- * Returns a Promise object that is rejected with the given reason.
- *
- * @func rejectP
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/1.16.0|v1.16.0}
- * @category Function
- * @sig a -> Promise a
- * @param {*} [reason=undefined] Reason why this Promise rejected
- * @return {Promise} A Promise that is rejected with the given reason
- * @see {@link RA.resolveP|resolveP}
- * @example
- *
- * RA.rejectP(); //=> Promise(undefined)
- * RA.rejectP('a'); //=> Promise('a')
- * RA.rejectP([1, 2, 3]); //=> Promise([1, 2, 3])
- */
-const rejectP = bind(Promise.reject, Promise);
-
-export default rejectP;

package/src/renameKey.js

@@ -1,33 +0,0 @@
-import { curry } from 'ramda';
-
-import renameKeys from './renameKeys.js';
-
-/**
- * Creates a new object with the own properties of the provided object, but a
- * single key is renamed from `oldKey` to `newKey`.
- *
- * Keep in mind that in the case of keys conflict is behavior undefined and
- * the result may vary between various JS engines!
- *
- * @func renameKey
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/4.1.0|v4.1.0}
- * @category Object
- * @sig (String a, String b) => a -> b ->  {a: *} -> {b: *}
- * @param {!string} oldKey
- * @param {!string} newKey
- * @param {!Object} obj
- * @return {!Object} New object with renamed key
- * @see {@link https://github.com/ramda/ramda/wiki/Cookbook#rename-key-of-an-object|Ramda Cookbook}, {@link RA.renameKeyWith|renameKeyWith}
- * @example
- *
- * const input = { firstName: 'Elisia', age: 22, type: 'human' };
- *
- * RA.renameKey('firstName', 'name')(input);
- * //=> { name: 'Elisia', age: 22, type: 'human' }
- */
-const renameKey = curry((oldKey, newKey, obj) =>
-  renameKeys({ [oldKey]: newKey }, obj)
-);
-
-export default renameKey;

package/src/renameKeyWith.js

@@ -1,30 +0,0 @@
-import { curry, equals, when } from 'ramda';
-
-import renameKeysWith from './renameKeysWith.js';
-
-/**
- * Creates a new object with the own properties of the provided object, but the
- * key `key` renamed according to logic of renaming function.
- *
- * Keep in mind that in case the new key name already existed on the object,
- * the behaviour is undefined and the result may vary between various JS engines!
- *
- * @func renameKeyWith
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.29.0|v2.29.0}
- * @category Object
- * @sig (k -> k) -> k -> {k: v} -> {k: v}
- * @param {Function} fn Function that renames the keys
- * @param {!string} key Key to rename
- * @param {!Object} obj Provided object
- * @return {!Object} New object with renamed key
- * @see {@link RA.renameKeysWith|renameKeysWith}
- * @example
- *
- * RA.renameKeyWith(R.concat('a'), 'A', { A: 1 }) //=> { aA: 1 }
- */
-const renameKeyWith = curry((fn, key, obj) =>
-  renameKeysWith(when(equals(key), fn), obj)
-);
-
-export default renameKeyWith;

package/src/renameKeys.js

@@ -1,40 +0,0 @@
-import { curry, has } from 'ramda';
-
-import renameKeysWith from './renameKeysWith.js';
-
-const valueOrKey = (keysMap) => (key) => {
-  if (has(key, keysMap)) {
-    return keysMap[key];
-  }
-  return key;
-};
-
-/**
- * Creates a new object with the own properties of the provided object, but the
- * keys renamed according to the keysMap object as `{oldKey: newKey}`.
- * When some key is not found in the keysMap, then it's passed as-is.
- *
- * Keep in mind that in the case of keys conflict is behaviour undefined and
- * the result may vary between various JS engines!
- *
- * @func renameKeys
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/1.5.0|v1.5.0}
- * @category Object
- * @sig {a: b} -> {a: *} -> {b: *}
- * @param {!Object} keysMap
- * @param {!Object} obj
- * @return {!Object} New object with renamed keys
- * @see {@link https://github.com/ramda/ramda/wiki/Cookbook#rename-keys-of-an-object|Ramda Cookbook}, {@link RA.renameKeysWith|renameKeysWith}
- * @example
- *
- * const input = { firstName: 'Elisia', age: 22, type: 'human' };
- *
- * RA.renameKeys({ firstName: 'name', type: 'kind', foo: 'bar' })(input);
- * //=> { name: 'Elisia', age: 22, kind: 'human' }
- */
-const renameKeys = curry((keysMap, obj) =>
-  renameKeysWith(valueOrKey(keysMap), obj)
-);
-
-export default renameKeys;

package/src/renameKeysWith.js

@@ -1,27 +0,0 @@
-import { curry, toPairs, pipe, map, over, lensIndex, fromPairs } from 'ramda';
-
-/**
- * Creates a new object with the own properties of the provided object, but the
- * keys renamed according to logic of renaming function.
- *
- * Keep in mind that in the case of keys conflict is behaviour undefined and
- * the result may vary between various JS engines!
- *
- * @func renameKeysWith
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/1.5.0|v1.5.0}
- * @category Object
- * @sig (a -> b) -> {a: *} -> {b: *}
- * @param {Function} fn Function that renames the keys
- * @param {!Object} obj Provided object
- * @return {!Object} New object with renamed keys
- * @see {@link https://github.com/ramda/ramda/wiki/Cookbook#rename-keys-of-an-object-by-a-function|Ramda Cookbook}, {@link RA.renameKeys|renameKeys}
- * @example
- *
- * RA.renameKeysWith(R.concat('a'), { A: 1, B: 2, C: 3 }) //=> { aA: 1, aB: 2, aC: 3 }
- */
-const renameKeysWith = curry((fn, obj) =>
-  pipe(toPairs, map(over(lensIndex(0), fn)), fromPairs)(obj)
-);
-
-export default renameKeysWith;

package/src/repeatStr.js

@@ -1,30 +0,0 @@
-import { curry, invoker, flip } from 'ramda';
-
-import ponyfill from './internal/ponyfills/String.repeat.js';
-import isFunction from './isFunction.js';
-
-export const repeatStrPonyfill = curry(ponyfill);
-
-export const repeatStrInvoker = flip(invoker(1, 'repeat'));
-
-/**
- * Constructs and returns a new string which contains the specified
- * number of copies of the string on which it was called, concatenated together.
- *
- * @func repeatStr
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.11.0|v2.11.0}
- * @category List
- * @sig String -> Number -> String
- * @param {string} value String value to be repeated
- * @param {number} count An integer between 0 and +∞: [0, +∞), indicating the number of times to repeat the string in the newly-created string that is to be returned
- * @return {string} A new string containing the specified number of copies of the given string
- * @example
- *
- * RA.repeatStr('a', 3); //=> 'aaa'
- */
-const repeatStr = isFunction(String.prototype.repeat)
-  ? repeatStrInvoker
-  : repeatStrPonyfill;
-
-export default repeatStr;

package/src/replaceAll.js

@@ -1,35 +0,0 @@
-import { curryN, invoker } from 'ramda';
-
-import isFunction from './isFunction.js';
-import ponyfill from './internal/ponyfills/String.replaceAll.js';
-
-export const replaceAllPonyfill = curryN(3, ponyfill);
-
-export const replaceAllInvoker = invoker(2, 'replaceAll');
-
-/**
- * Replaces all substring matches in a string with a replacement.
- *
- * @func replaceAll
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.17.0|v2.17.0}
- * @category String
- * @sig String -> String -> String -> String
- * @param {string} searchValue The substring or a global RegExp to match
- * @param {string} replaceValue The string to replace the matches with
- * @param {string} str The String to do the search and replacement in
- * @return {string} A new string containing all the `searchValue` replaced with the `replaceValue`
- * @throws {TypeError} When invalid arguments provided
- * @see {@link http://ramdajs.com/docs/#replace|R.replace}, {@link https://github.com/tc39/proposal-string-replaceall|TC39 proposal}
- * @example
- *
- * RA.replaceAll('ac', 'ef', 'ac ab ac ab'); //=> 'ef ab ef ab'
- * RA.replaceAll('', '_', 'xxx'); //=> '_x_x_x_'
- * RA.replaceAll(/x/g, 'v', 'xxx'); //=> 'vvv'
- * RA.replaceAll(/x/, 'v', 'xxx'); //=> TypeError
- */
-const replaceAll = isFunction(String.prototype.replaceAll)
-  ? replaceAllInvoker
-  : replaceAllPonyfill;
-
-export default replaceAll;

package/src/resolveP.js

@@ -1,28 +0,0 @@
-import { bind } from 'ramda';
-
-/* eslint-disable max-len */
-/**
- * Composable shortcut for `Promise.resolve`.
- *
- * Returns a Promise object that is resolved with the given value.
- * If the value is a thenable (i.e. has a "then" method), the returned promise will
- * "follow" that thenable, adopting its eventual state.
- *
- * @func resolveP
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/1.16.0|v1.16.0}
- * @category Function
- * @sig a -> Promise a
- * @param {*} [value=undefined] Argument to be resolved by this Promise. Can also be a Promise or a thenable to resolve
- * @return {Promise} A Promise that is resolved with the given value, or the promise passed as value, if the value was a promise object
- * @see {@link RA.rejectP|rejectP}
- * @example
- *
- * RA.resolveP(); //=> Promise(undefined)
- * RA.resolveP('a'); //=> Promise('a')
- * RA.resolveP([1, 2, 3]); //=> Promise([1, 2, 3])
- */
-/* eslint-enable max-len */
-const resolveP = bind(Promise.resolve, Promise);
-
-export default resolveP;

package/src/round.js

@@ -1,26 +0,0 @@
-import { bind, curryN } from 'ramda';
-
-/**
- * Returns the value of a number rounded to the nearest integer.
- *
- * @func round
- * @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 round
- * @return {number} The value of the given number rounded to the nearest integer
- * @example
- *
- * RA.round(0.9); //=> 1
- * RA.round(5.95); //=> 6
- * RA.round(5.5); //=> 6
- * RA.round(5.05); //=> 5
- * RA.round(-5.05); //=> -5
- * RA.round(-5.5); //=> -5
- * RA.round(-5.95); //=> -6
- */
-
-const round = curryN(1, bind(Math.round, Math));
-
-export default round;

package/src/seq.js

@@ -1,38 +0,0 @@
-import { curry, map, tap } from 'ramda';
-
-/* eslint-disable max-len */
-/**
- * Runs the given list of functions in order with the supplied object, then returns the object.
- * Also known as the normal order sequencing combinator.
- *
- * Acts as a transducer if a transformer is given as second parameter.
- *
- * @func seq
- * @aliases sequencing
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.3.0|v2.3.0}
- * @category Function
- * @sig [(a -> *), (a -> *), ...] -> a -> a
- * @param {Array} fns The list of functions to call in order with `x` whose return values will be thrown away
- * @param {*} x
- * @return {*} `x`
- * @see {@link http://ramdajs.com/docs/#tap|R.tap}, {@link http://www.cs.rpi.edu/academics/courses/spring11/proglang/handouts/lambda-calculus-chapter.pdf|sequencing combinator explained}
- * @example
- *
- * RA.seq([console.info, console.log])('foo'); //=> prints 'foo' via info then log
- *
- * // usage in composition
- * R.pipe(
- *   R.concat('prefix '),
- *   RA.seq([
- *     console.info, //=> prints 'prefix test'
- *     console.log //=> prints 'prefix test'
- *   ]),
- *   R.toUpper
- * )('test'); //=> 'PREFIX TEST'
- */
-/* eslint-enable max-len */
-
-const seq = curry((fns, x) => tap((tx) => map((fn) => fn(tx))(fns))(x));
-
-export default seq;