rambda 8.1.0 → 8.3.0

package/dist/rambda.js

@@ -13,6 +13,121 @@ function add(a, b) {
   return Number(a) + Number(b);
 }
 
+function _concat(set1, set2) {
+  set1 = set1 || [];
+  set2 = set2 || [];
+  let idx;
+  const len1 = set1.length;
+  const len2 = set2.length;
+  const result = [];
+  idx = 0;
+  while (idx < len1) {
+    result[result.length] = set1[idx];
+    idx += 1;
+  }
+  idx = 0;
+  while (idx < len2) {
+    result[result.length] = set2[idx];
+    idx += 1;
+  }
+  return result;
+}
+
+function _arity(n, fn) {
+  switch (n) {
+    case 0:
+      return function () {
+        return fn.apply(this, arguments);
+      };
+    case 1:
+      return function (_1) {
+        return fn.apply(this, arguments);
+      };
+    case 2:
+      return function (_1, _2) {
+        return fn.apply(this, arguments);
+      };
+    case 3:
+      return function (_1, _2, _3) {
+        return fn.apply(this, arguments);
+      };
+    case 4:
+      return function (_1, _2, _3, _4) {
+        return fn.apply(this, arguments);
+      };
+    case 5:
+      return function (_1, _2, _3, _4, _5) {
+        return fn.apply(this, arguments);
+      };
+    case 6:
+      return function (_1, _2, _3, _4, _5, _6) {
+        return fn.apply(this, arguments);
+      };
+    case 7:
+      return function (_1, _2, _3, _4, _5, _6, _7) {
+        return fn.apply(this, arguments);
+      };
+    case 8:
+      return function (_1, _2, _3, _4, _5, _6, _7, _8) {
+        return fn.apply(this, arguments);
+      };
+    case 9:
+      return function (_1, _2, _3, _4, _5, _6, _7, _8, _9) {
+        return fn.apply(this, arguments);
+      };
+    default:
+      return function (_1, _2, _3, _4, _5, _6, _7, _8, _9, _10) {
+        return fn.apply(this, arguments);
+      };
+  }
+}
+
+function _curryN(n, cache, fn) {
+  return function () {
+    let ci = 0;
+    let ai = 0;
+    const cl = cache.length;
+    const al = arguments.length;
+    const args = new Array(cl + al);
+    while (ci < cl) {
+      args[ci] = cache[ci];
+      ci++;
+    }
+    while (ai < al) {
+      args[cl + ai] = arguments[ai];
+      ai++;
+    }
+    const remaining = n - args.length;
+    return args.length >= n ? fn.apply(this, args) : _arity(remaining, _curryN(n, args, fn));
+  };
+}
+function curryN(n, fn) {
+  if (arguments.length === 1) return _fn => curryN(n, _fn);
+  if (n > 10) {
+    throw new Error('First argument to _arity must be a non-negative integer no greater than ten');
+  }
+  return _arity(n, _curryN(n, [], fn));
+}
+
+function addIndex(originalFunction, initialIndexFn = () => 0, loopIndexChange = x => x + 1) {
+  return curryN(originalFunction.length, function () {
+    const origFn = arguments[0];
+    const list = arguments[arguments.length - 1];
+    let idx = initialIndexFn(list.length);
+    const args = Array.prototype.slice.call(arguments, 0);
+    args[0] = function () {
+      const result = origFn.apply(this, _concat(arguments, [idx, list]));
+      idx = loopIndexChange(idx);
+      return result;
+    };
+    return originalFunction.apply(this, args);
+  });
+}
+
+function addIndexRight(originalFunction) {
+  return addIndex(originalFunction, listLength => listLength - 1, x => x - 1);
+}
+
 const cloneList = list => Array.prototype.slice.call(list);
 
 function curry(fn, args = []) {
@@ -83,6 +198,28 @@ function anyPass(predicates) {
   };
 }
 
+function ap(functions, input) {
+  if (arguments.length === 1) {
+    return _inputs => ap(functions, _inputs);
+  }
+  return functions.reduce((acc, fn) => [...acc, ...input.map(fn)], []);
+}
+
+function aperture(step, list) {
+  if (arguments.length === 1) {
+    return _list => aperture(step, _list);
+  }
+  if (step > list.length) return [];
+  let idx = 0;
+  const limit = list.length - (step - 1);
+  const acc = new Array(limit);
+  while (idx < limit) {
+    acc[idx] = list.slice(idx, idx + step);
+    idx += 1;
+  }
+  return acc;
+}
+
 function append(x, input) {
   if (arguments.length === 1) return _input => append(x, _input);
   if (typeof input === 'string') return input.split('').concat(x);
@@ -168,6 +305,26 @@ function applySpec(spec, ...args) {
   return toReturn;
 }
 
+function applyTo(input, fn) {
+  if (arguments.length === 1) {
+    return _fn => applyTo(input, _fn);
+  }
+  return fn(input);
+}
+
+function createCompareFunction(a, b, winner, loser) {
+  if (a === b) return 0;
+  return a < b ? winner : loser;
+}
+function ascend(getFunction, a, b) {
+  if (arguments.length === 1) {
+    return (_a, _b) => ascend(getFunction, _a, _b);
+  }
+  const aValue = getFunction(a);
+  const bValue = getFunction(b);
+  return createCompareFunction(aValue, bValue, -1, 1);
+}
+
 function assocFn(prop, newValue, obj) {
   return Object.assign({}, obj, {
     [prop]: newValue
@@ -200,79 +357,9 @@ function assocPathFn(path, newValue, input) {
 }
 const assocPath = curry(assocPathFn);
 
-function _curryN(n, cache, fn) {
-  return function () {
-    let ci = 0;
-    let ai = 0;
-    const cl = cache.length;
-    const al = arguments.length;
-    const args = new Array(cl + al);
-    while (ci < cl) {
-      args[ci] = cache[ci];
-      ci++;
-    }
-    while (ai < al) {
-      args[cl + ai] = arguments[ai];
-      ai++;
-    }
-    const remaining = n - args.length;
-    return args.length >= n ? fn.apply(this, args) : _arity$1(remaining, _curryN(n, args, fn));
-  };
-}
-function _arity$1(n, fn) {
-  switch (n) {
-    case 0:
-      return function () {
-        return fn.apply(this, arguments);
-      };
-    case 1:
-      return function (_1) {
-        return fn.apply(this, arguments);
-      };
-    case 2:
-      return function (_1, _2) {
-        return fn.apply(this, arguments);
-      };
-    case 3:
-      return function (_1, _2, _3) {
-        return fn.apply(this, arguments);
-      };
-    case 4:
-      return function (_1, _2, _3, _4) {
-        return fn.apply(this, arguments);
-      };
-    case 5:
-      return function (_1, _2, _3, _4, _5) {
-        return fn.apply(this, arguments);
-      };
-    case 6:
-      return function (_1, _2, _3, _4, _5, _6) {
-        return fn.apply(this, arguments);
-      };
-    case 7:
-      return function (_1, _2, _3, _4, _5, _6, _7) {
-        return fn.apply(this, arguments);
-      };
-    case 8:
-      return function (_1, _2, _3, _4, _5, _6, _7, _8) {
-        return fn.apply(this, arguments);
-      };
-    case 9:
-      return function (_1, _2, _3, _4, _5, _6, _7, _8, _9) {
-        return fn.apply(this, arguments);
-      };
-    default:
-      return function (_1, _2, _3, _4, _5, _6, _7, _8, _9, _10) {
-        return fn.apply(this, arguments);
-      };
-  }
-}
-function curryN(n, fn) {
-  if (arguments.length === 1) return _fn => curryN(n, _fn);
-  if (n > 10) {
-    throw new Error('First argument to _arity must be a non-negative integer no greater than ten');
-  }
-  return _arity$1(n, _curryN(n, [], fn));
+function binary(fn) {
+  if (fn.length <= 2) return fn;
+  return (a, b) => fn(a, b);
 }
 
 function bind(fn, thisObj) {
@@ -287,6 +374,8 @@ function both(f, g) {
   return (...input) => f(...input) && g(...input);
 }
 
+const call = (fn, ...inputs) => fn(...inputs);
+
 function chain(fn, list) {
   if (arguments.length === 1) {
     return _list => chain(fn, _list);
@@ -314,10 +403,6 @@ function clone(input) {
   return out;
 }
 
-function complement(fn) {
-  return (...input) => !fn(...input);
-}
-
 class ReduceStopper {
   constructor(value) {
     this.value = value;
@@ -344,56 +429,35 @@ function reduceFn(reducer, acc, list) {
 const reduce = curry(reduceFn);
 const reduceStopper = value => new ReduceStopper(value);
 
-function _arity(n, fn) {
-  switch (n) {
-    case 0:
-      return function () {
-        return fn.apply(this, arguments);
-      };
-    case 1:
-      return function (a0) {
-        return fn.apply(this, arguments);
-      };
-    case 2:
-      return function (a0, a1) {
-        return fn.apply(this, arguments);
-      };
-    case 3:
-      return function (a0, a1, a2) {
-        return fn.apply(this, arguments);
-      };
-    case 4:
-      return function (a0, a1, a2, a3) {
-        return fn.apply(this, arguments);
-      };
-    case 5:
-      return function (a0, a1, a2, a3, a4) {
-        return fn.apply(this, arguments);
-      };
-    case 6:
-      return function (a0, a1, a2, a3, a4, a5) {
-        return fn.apply(this, arguments);
-      };
-    case 7:
-      return function (a0, a1, a2, a3, a4, a5, a6) {
-        return fn.apply(this, arguments);
-      };
-    case 8:
-      return function (a0, a1, a2, a3, a4, a5, a6, a7) {
-        return fn.apply(this, arguments);
-      };
-    case 9:
-      return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) {
-        return fn.apply(this, arguments);
-      };
-    case 10:
-      return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {
-        return fn.apply(this, arguments);
-      };
-    default:
-      throw new Error('First argument to _arity must be a non-negative integer no greater than ten');
+function collectBy(fn, list) {
+  if (arguments.length === 1) {
+    return _list => collectBy(fn, _list);
+  }
+  const group = reduce((o, x) => {
+    const tag = fn(x);
+    if (o[tag] === undefined) {
+      o[tag] = [];
+    }
+    o[tag].push(x);
+    return o;
+  }, {}, list);
+  const newList = [];
+  for (const tag in group) {
+    newList.push(group[tag]);
   }
+  return newList;
+}
+
+function comparator(fn) {
+  return function (a, b) {
+    return fn(a, b) ? -1 : fn(b, a) ? 1 : 0;
+  };
+}
+
+function complement(fn) {
+  return (...input) => !fn(...input);
 }
+
 function _pipe(f, g) {
   return function () {
     return g.call(this, f.apply(this, arguments));
@@ -413,6 +477,49 @@ function compose() {
   return pipe.apply(this, Array.prototype.slice.call(arguments, 0).reverse());
 }
 
+function head(listOrString) {
+  if (typeof listOrString === 'string') return listOrString[0] || '';
+  return listOrString[0];
+}
+
+function identity(x) {
+  return x;
+}
+
+function reverse(listOrString) {
+  if (typeof listOrString === 'string') {
+    return listOrString.split('').reverse().join('');
+  }
+  const clone = listOrString.slice();
+  return clone.reverse();
+}
+
+function drop(howManyToDrop, listOrString) {
+  if (arguments.length === 1) return _list => drop(howManyToDrop, _list);
+  return listOrString.slice(howManyToDrop > 0 ? howManyToDrop : 0);
+}
+
+function tail(listOrString) {
+  return drop(1, listOrString);
+}
+
+function pipeWith(xf, list) {
+  if (list.length <= 0) {
+    return identity;
+  }
+  const headList = head(list);
+  const tailList = tail(list);
+  return _arity(headList.length, function () {
+    return reduce(function (result, f) {
+      return xf.call(this, f, result);
+    }, headList.apply(this, arguments), tailList);
+  });
+}
+function composeWith(xf, list) {
+  if (arguments.length === 1) return _list => composeWith(xf, _list);
+  return pipeWith.apply(this, [xf, reverse(list)]);
+}
+
 function concat(x, y) {
   if (arguments.length === 1) return _y => concat(x, _y);
   return typeof x === 'string' ? `${x}${y}` : [...x, ...y];
@@ -521,6 +628,15 @@ function defaultTo(defaultArgument, input) {
   return isFalsy(input) ? defaultArgument : input;
 }
 
+function descend(getFunction, a, b) {
+  if (arguments.length === 1) {
+    return (_a, _b) => descend(getFunction, _a, _b);
+  }
+  const aValue = getFunction(a);
+  const bValue = getFunction(b);
+  return createCompareFunction(aValue, bValue, 1, -1);
+}
+
 function type(input) {
   if (input === null) {
     return 'Null';
@@ -756,11 +872,6 @@ function divide(a, b) {
   return a / b;
 }
 
-function drop(howManyToDrop, listOrString) {
-  if (arguments.length === 1) return _list => drop(howManyToDrop, _list);
-  return listOrString.slice(howManyToDrop > 0 ? howManyToDrop : 0);
-}
-
 function dropLast(howManyToDrop, listOrString) {
   if (arguments.length === 1) {
     return _listOrString => dropLast(howManyToDrop, _listOrString);
@@ -1154,11 +1265,6 @@ function hasPath(pathInput, obj) {
   return path(pathInput, obj) !== undefined;
 }
 
-function head(listOrString) {
-  if (typeof listOrString === 'string') return listOrString[0] || '';
-  return listOrString[0];
-}
-
 function _objectIs(a, b) {
   if (a === b) {
     return a !== 0 || 1 / a === 1 / b;
@@ -1172,10 +1278,6 @@ function identical(a, b) {
   return objectIs(a, b);
 }
 
-function identity(x) {
-  return x;
-}
-
 function ifElseFn(condition, onTrue, onFalse) {
   return (...input) => {
     const conditionResult = typeof condition === 'boolean' ? condition : condition(...input);
@@ -1828,14 +1930,6 @@ function replaceFn(pattern, replacer, str) {
 }
 const replace = curry(replaceFn);
 
-function reverse(listOrString) {
-  if (typeof listOrString === 'string') {
-    return listOrString.split('').reverse().join('');
-  }
-  const clone = listOrString.slice();
-  return clone.reverse();
-}
-
 function setFn(lens, replacer, x) {
   return over(lens, always(replacer), x);
 }
@@ -1955,10 +2049,6 @@ function symmetricDifference(x, y) {
   return concat(filter(value => !includes(value, y), x), filter(value => !includes(value, x), y));
 }
 
-function tail(listOrString) {
-  return drop(1, listOrString);
-}
-
 function takeLast(howMany, listOrString) {
   if (arguments.length === 1) return _listOrString => takeLast(howMany, _listOrString);
   const len = listOrString.length;
@@ -2236,11 +2326,12 @@ const zipWith = curry(zipWithFn);
 exports.F = F;
 exports.T = T;
 exports.__findHighestArity = __findHighestArity;
-exports._arity = _arity;
 exports._indexOf = _indexOf;
 exports._lastIndexOf = _lastIndexOf;
 exports._pipe = _pipe;
 exports.add = add;
+exports.addIndex = addIndex;
+exports.addIndexRight = addIndexRight;
 exports.adjust = adjust;
 exports.all = all;
 exports.allPass = allPass;
@@ -2248,27 +2339,38 @@ exports.always = always;
 exports.and = and;
 exports.any = any;
 exports.anyPass = anyPass;
+exports.ap = ap;
+exports.aperture = aperture;
 exports.append = append;
 exports.apply = apply;
 exports.applySpec = applySpec;
+exports.applyTo = applyTo;
+exports.ascend = ascend;
 exports.assoc = assoc;
 exports.assocPath = assocPath;
+exports.binary = binary;
 exports.bind = bind;
 exports.both = both;
+exports.call = call;
 exports.chain = chain;
 exports.clamp = clamp;
 exports.clone = clone;
+exports.collectBy = collectBy;
+exports.comparator = comparator;
 exports.complement = complement;
 exports.compose = compose;
+exports.composeWith = composeWith;
 exports.concat = concat;
 exports.cond = cond;
 exports.converge = converge;
 exports.count = count;
 exports.countBy = countBy;
+exports.createCompareFunction = createCompareFunction;
 exports.curry = curry;
 exports.curryN = curryN;
 exports.dec = dec;
 exports.defaultTo = defaultTo;
+exports.descend = descend;
 exports.difference = difference;
 exports.differenceWith = differenceWith;
 exports.differenceWithFn = differenceWithFn;
@@ -2376,6 +2478,7 @@ exports.paths = paths;
 exports.pick = pick;
 exports.pickAll = pickAll;
 exports.pipe = pipe;
+exports.pipeWith = pipeWith;
 exports.pluck = pluck;
 exports.prepend = prepend;
 exports.product = product;