rambda 6.8.3 → 7.0.2

package/dist/rambda.js

@@ -19,10 +19,14 @@ function curry(fn, args = []) {
   return (..._args) => (rest => rest.length >= fn.length ? fn(...rest) : curry(fn, rest))([...args, ..._args]);
 }
 
+const cloneList = list => {
+  return Array.prototype.slice.call(list);
+};
+
 function adjustFn(index, replaceFn, list) {
   const actualIndex = index < 0 ? list.length + index : index;
   if (index >= list.length || actualIndex < 0) return list;
-  const clone = list.slice();
+  const clone = cloneList(list);
   clone[actualIndex] = replaceFn(clone[actualIndex]);
   return clone;
 }
@@ -40,11 +44,11 @@ function all(predicate, list) {
 }
 
 function allPass(predicates) {
-  return input => {
+  return (...input) => {
     let counter = 0;
 
     while (counter < predicates.length) {
-      if (!predicates[counter](input)) {
+      if (!predicates[counter](...input)) {
         return false;
       }
 
@@ -80,11 +84,11 @@ function any(predicate, list) {
 }
 
 function anyPass(predicates) {
-  return input => {
+  return (...input) => {
     let counter = 0;
 
     while (counter < predicates.length) {
-      if (predicates[counter](input)) {
+      if (predicates[counter](...input)) {
         return true;
       }
 
@@ -98,11 +102,19 @@ function anyPass(predicates) {
 function append(x, input) {
   if (arguments.length === 1) return _input => append(x, _input);
   if (typeof input === 'string') return input.split('').concat(x);
-  const clone = input.slice();
+  const clone = cloneList(input);
   clone.push(x);
   return clone;
 }
 
+function apply(fn, args) {
+  if (arguments.length === 1) {
+    return _args => apply(fn, _args);
+  }
+
+  return fn.apply(this, args);
+}
+
 const _isArray = Array.isArray;
 
 function __findHighestArity(spec, max = 0) {
@@ -220,7 +232,7 @@ function assocPathFn(path, newValue, input) {
   }
 
   if (_isInteger(index) && _isArray(input)) {
-    const arr = input.slice();
+    const arr = cloneList(input);
     arr[index] = newValue;
     return arr;
   }
@@ -230,87 +242,6 @@ function assocPathFn(path, newValue, input) {
 
 const assocPath = curry(assocPathFn);
 
-function both(f, g) {
-  if (arguments.length === 1) return _g => both(f, _g);
-  return (...input) => f(...input) && g(...input);
-}
-
-function chain(fn, list) {
-  if (arguments.length === 1) {
-    return _list => chain(fn, _list);
-  }
-
-  return [].concat(...list.map(fn));
-}
-
-function clampFn(min, max, input) {
-  if (min > max) {
-    throw new Error('min must not be greater than max in clamp(min, max, value)');
-  }
-
-  if (input >= min && input <= max) return input;
-  if (input > max) return max;
-  if (input < min) return min;
-}
-
-const clamp = curry(clampFn);
-
-function clone(input) {
-  const out = _isArray(input) ? Array(input.length) : {};
-  if (input && input.getTime) return new Date(input.getTime());
-
-  for (const key in input) {
-    const v = input[key];
-    out[key] = typeof v === 'object' && v !== null ? v.getTime ? new Date(v.getTime()) : clone(v) : v;
-  }
-
-  return out;
-}
-
-function complement(fn) {
-  return (...input) => !fn(...input);
-}
-
-function compose(...fns) {
-  if (fns.length === 0) {
-    throw new Error('compose requires at least one argument');
-  }
-
-  return (...args) => {
-    const list = fns.slice();
-
-    if (list.length > 0) {
-      const fn = list.pop();
-      let result = fn(...args);
-
-      while (list.length > 0) {
-        result = list.pop()(result);
-      }
-
-      return result;
-    }
-  };
-}
-
-function concat(x, y) {
-  if (arguments.length === 1) return _y => concat(x, _y);
-  return typeof x === 'string' ? `${x}${y}` : [...x, ...y];
-}
-
-function cond(conditions) {
-  return input => {
-    let done = false;
-    let toReturn;
-    conditions.forEach(([predicate, resultClosure]) => {
-      if (!done && predicate(input)) {
-        done = true;
-        toReturn = resultClosure(input);
-      }
-    });
-    return toReturn;
-  };
-}
-
 function _curryN(n, cache, fn) {
   return function () {
     let ci = 0;
@@ -403,6 +334,95 @@ function curryN(n, fn) {
   return _arity(n, _curryN(n, [], fn));
 }
 
+function bind(fn, thisObj) {
+  if (arguments.length === 1) {
+    return _thisObj => bind(fn, _thisObj);
+  }
+
+  return curryN(fn.length, (...args) => fn.apply(thisObj, args));
+}
+
+function both(f, g) {
+  if (arguments.length === 1) return _g => both(f, _g);
+  return (...input) => f(...input) && g(...input);
+}
+
+function chain(fn, list) {
+  if (arguments.length === 1) {
+    return _list => chain(fn, _list);
+  }
+
+  return [].concat(...list.map(fn));
+}
+
+function clampFn(min, max, input) {
+  if (min > max) {
+    throw new Error('min must not be greater than max in clamp(min, max, value)');
+  }
+
+  if (input >= min && input <= max) return input;
+  if (input > max) return max;
+  if (input < min) return min;
+}
+
+const clamp = curry(clampFn);
+
+function clone(input) {
+  const out = _isArray(input) ? Array(input.length) : {};
+  if (input && input.getTime) return new Date(input.getTime());
+
+  for (const key in input) {
+    const v = input[key];
+    out[key] = typeof v === 'object' && v !== null ? v.getTime ? new Date(v.getTime()) : clone(v) : v;
+  }
+
+  return out;
+}
+
+function complement(fn) {
+  return (...input) => !fn(...input);
+}
+
+function compose(...fns) {
+  if (fns.length === 0) {
+    throw new Error('compose requires at least one argument');
+  }
+
+  return function (...args) {
+    const list = fns.slice();
+
+    if (list.length > 0) {
+      const fn = list.pop();
+      let result = fn.apply(this, args);
+
+      while (list.length > 0) {
+        result = list.pop()(result);
+      }
+
+      return result;
+    }
+  };
+}
+
+function concat(x, y) {
+  if (arguments.length === 1) return _y => concat(x, _y);
+  return typeof x === 'string' ? `${x}${y}` : [...x, ...y];
+}
+
+function cond(conditions) {
+  return input => {
+    let done = false;
+    let toReturn;
+    conditions.forEach(([predicate, resultClosure]) => {
+      if (!done && predicate(input)) {
+        done = true;
+        toReturn = resultClosure(input);
+      }
+    });
+    return toReturn;
+  };
+}
+
 const _keys = Object.keys;
 
 function mapArray(fn, list, isIndexed = false) {
@@ -433,11 +453,15 @@ function mapObject(fn, obj) {
   return willReturn;
 }
 const mapObjIndexed = mapObject;
-function map(fn, list) {
-  if (arguments.length === 1) return _list => map(fn, _list);
-  if (list === undefined) return [];
-  if (_isArray(list)) return mapArray(fn, list);
-  return mapObject(fn, list);
+function map(fn, iterable) {
+  if (arguments.length === 1) return _iterable => map(fn, _iterable);
+
+  if (!iterable) {
+    throw new Error('Incorrect iterable input');
+  }
+
+  if (_isArray(iterable)) return mapArray(fn, iterable);
+  return mapObject(fn, iterable);
 }
 
 function max(x, y) {
@@ -486,34 +510,83 @@ function defaultTo(defaultArgument, input) {
 }
 
 function type(input) {
-  const typeOf = typeof input;
-
   if (input === null) {
     return 'Null';
   } else if (input === undefined) {
     return 'Undefined';
-  } else if (typeOf === 'boolean') {
-    return 'Boolean';
-  } else if (typeOf === 'number') {
-    return Number.isNaN(input) ? 'NaN' : 'Number';
-  } else if (typeOf === 'string') {
-    return 'String';
-  } else if (_isArray(input)) {
-    return 'Array';
-  } else if (typeOf === 'symbol') {
-    return 'Symbol';
-  } else if (input instanceof RegExp) {
-    return 'RegExp';
-  }
-
-  const asStr = input && input.toString ? input.toString() : '';
-  if (['true', 'false'].includes(asStr)) return 'Boolean';
-  if (!Number.isNaN(Number(asStr))) return 'Number';
-  if (asStr.startsWith('async')) return 'Async';
-  if (asStr === '[object Promise]') return 'Promise';
-  if (typeOf === 'function') return 'Function';
-  if (input instanceof String) return 'String';
-  return 'Object';
+  } else if (Number.isNaN(input)) {
+    return 'NaN';
+  }
+
+  const typeResult = Object.prototype.toString.call(input).slice(8, -1);
+  return typeResult === 'AsyncFunction' ? 'Async' : typeResult;
+}
+
+function _lastIndexOf(valueToFind, list) {
+  if (!_isArray(list)) {
+    throw new Error(`Cannot read property 'indexOf' of ${list}`);
+  }
+
+  const typeOfValue = type(valueToFind);
+  if (!['Object', 'Array', 'NaN', 'RegExp'].includes(typeOfValue)) return list.lastIndexOf(valueToFind);
+  const {
+    length
+  } = list;
+  let index = length;
+  let foundIndex = -1;
+
+  while (--index > -1 && foundIndex === -1) {
+    if (equals(list[index], valueToFind)) {
+      foundIndex = index;
+    }
+  }
+
+  return foundIndex;
+}
+function _indexOf(valueToFind, list) {
+  if (!_isArray(list)) {
+    throw new Error(`Cannot read property 'indexOf' of ${list}`);
+  }
+
+  const typeOfValue = type(valueToFind);
+  if (!['Object', 'Array', 'NaN', 'RegExp'].includes(typeOfValue)) return list.indexOf(valueToFind);
+  let index = -1;
+  let foundIndex = -1;
+  const {
+    length
+  } = list;
+
+  while (++index < length && foundIndex === -1) {
+    if (equals(list[index], valueToFind)) {
+      foundIndex = index;
+    }
+  }
+
+  return foundIndex;
+}
+
+function _arrayFromIterator(iter) {
+  const list = [];
+  let next;
+
+  while (!(next = iter.next()).done) {
+    list.push(next.value);
+  }
+
+  return list;
+}
+
+function _equalsSets(a, b) {
+  if (a.size !== b.size) {
+    return false;
+  }
+
+  const aList = _arrayFromIterator(a.values());
+
+  const bList = _arrayFromIterator(b.values());
+
+  const filtered = aList.filter(aInstance => _indexOf(aInstance, bList) === -1);
+  return filtered.length === 0;
 }
 
 function parseError(maybeError) {
@@ -593,6 +666,10 @@ function equals(a, b) {
     return bError[0] ? aError[0] === bError[0] && aError[1] === bError[1] : false;
   }
 
+  if (aType === 'Set') {
+    return _equalsSets(a, b);
+  }
+
   if (aType === 'Object') {
     const aKeys = Object.keys(a);
 
@@ -617,44 +694,68 @@ function equals(a, b) {
   return false;
 }
 
-function includesArray(valueToFind, input) {
-  let index = -1;
+function includes(valueToFind, iterable) {
+  if (arguments.length === 1) return _iterable => includes(valueToFind, _iterable);
 
-  while (++index < input.length) {
-    if (equals(input[index], valueToFind)) {
-      return true;
-    }
+  if (typeof iterable === 'string') {
+    return iterable.includes(valueToFind);
   }
 
-  return false;
+  if (!iterable) {
+    throw new TypeError(`Cannot read property \'indexOf\' of ${iterable}`);
+  }
+
+  if (!_isArray(iterable)) return false;
+  return _indexOf(valueToFind, iterable) > -1;
 }
-function includes(valueToFind, input) {
-  if (arguments.length === 1) return _input => includes(valueToFind, _input);
 
-  if (typeof input === 'string') {
-    return input.includes(valueToFind);
+class _Set {
+  constructor() {
+    this.set = new Set();
+    this.items = {};
   }
 
-  if (!input) {
-    throw new TypeError(`Cannot read property \'indexOf\' of ${input}`);
-  }
+  checkUniqueness(item) {
+    const type$1 = type(item);
 
-  if (!_isArray(input)) return false;
-  return includesArray(valueToFind, input);
-}
+    if (['Null', 'Undefined', 'NaN'].includes(type$1)) {
+      if (type$1 in this.items) {
+        return false;
+      }
 
-function uniq(list) {
-  let index = -1;
-  const willReturn = [];
+      this.items[type$1] = true;
+      return true;
+    }
 
-  while (++index < list.length) {
-    const value = list[index];
+    if (!['Object', 'Array'].includes(type$1)) {
+      const prevSize = this.set.size;
+      this.set.add(item);
+      return this.set.size !== prevSize;
+    }
 
-    if (!includes(value, willReturn)) {
-      willReturn.push(value);
+    if (!(type$1 in this.items)) {
+      this.items[type$1] = [item];
+      return true;
+    }
+
+    if (_indexOf(item, this.items[type$1]) === -1) {
+      this.items[type$1].push(item);
+      return true;
     }
+
+    return false;
   }
 
+}
+
+function uniq(list) {
+  const set = new _Set();
+  const willReturn = [];
+  list.forEach(item => {
+    if (set.checkUniqueness(item)) {
+      willReturn.push(item);
+    }
+  });
   return willReturn;
 }
 
@@ -805,17 +906,33 @@ function either(firstPredicate, secondPredicate) {
   return (...input) => Boolean(firstPredicate(...input) || secondPredicate(...input));
 }
 
-function endsWith(target, str) {
-  if (arguments.length === 1) return _str => endsWith(target, _str);
-  return str.endsWith(target);
-}
+function endsWith(target, iterable) {
+  if (arguments.length === 1) return _iterable => endsWith(target, _iterable);
 
-function eqPropsFn(prop, obj1, obj2) {
-  if (!obj1 || !obj2) {
-    throw new Error('wrong object inputs are passed to R.eqProps');
+  if (typeof iterable === 'string') {
+    return iterable.endsWith(target);
   }
 
-  return equals(obj1[prop], obj2[prop]);
+  if (!_isArray(target)) return false;
+  const diff = iterable.length - target.length;
+  let correct = true;
+  const filtered = target.filter((x, index) => {
+    if (!correct) return false;
+    const result = equals(x, iterable[index + diff]);
+    if (!result) correct = false;
+    return result;
+  });
+  return filtered.length === target.length;
+}
+
+function prop(propToFind, obj) {
+  if (arguments.length === 1) return _obj => prop(propToFind, _obj);
+  if (!obj) return undefined;
+  return obj[propToFind];
+}
+
+function eqPropsFn(property, objA, objB) {
+  return equals(prop(property, objA), prop(property, objB));
 }
 
 const eqProps = curry(eqPropsFn);
@@ -904,12 +1021,13 @@ function filterArray(predicate, list, indexed = false) {
   return willReturn;
 }
 function filter(predicate, iterable) {
-  if (arguments.length === 1) {
-    return _iterable => filter(predicate, _iterable);
+  if (arguments.length === 1) return _iterable => filter(predicate, _iterable);
+
+  if (!iterable) {
+    throw new Error('Incorrect iterable input');
   }
 
-  if (!iterable) return [];
-  if (_isArray(iterable)) return filterArray(predicate, iterable);
+  if (_isArray(iterable)) return filterArray(predicate, iterable, false);
   return filterObject(predicate, iterable);
 }
 
@@ -995,7 +1113,7 @@ function flipFn(fn) {
       return fn(input[1], input[0], input[2], input[3]);
     }
 
-    throw new Error('R.flip doesn\'t work with arity > 4');
+    throw new Error("R.flip doesn't work with arity > 4");
   };
 }
 
@@ -1061,7 +1179,7 @@ function groupBy(groupFn, list) {
 
 function groupWith(compareFn, list) {
   if (!_isArray(list)) throw new TypeError('list.reduce is not a function');
-  const clone = list.slice();
+  const clone = cloneList(list);
   if (list.length === 1) return [clone];
   const toReturn = [];
   let holder = [];
@@ -1122,12 +1240,12 @@ function path(pathInput, obj) {
   return willReturn;
 }
 
-function hasPath(maybePath, obj) {
+function hasPath(pathInput, obj) {
   if (arguments.length === 1) {
-    return objHolder => hasPath(maybePath, objHolder);
+    return objHolder => hasPath(pathInput, objHolder);
   }
 
-  return path(maybePath, obj) !== undefined;
+  return path(pathInput, obj) !== undefined;
 }
 
 function head(listOrString) {
@@ -1149,8 +1267,8 @@ function identical(a, b) {
   return _objectIs$1(a, b);
 }
 
-function identity(input) {
-  return input;
+function identity(x) {
+  return x;
 }
 
 function ifElseFn(condition, onTrue, onFalse) {
@@ -1201,21 +1319,10 @@ function indexBy(condition, list) {
 
 function indexOf(valueToFind, list) {
   if (arguments.length === 1) {
-    return _list => indexOf(valueToFind, _list);
+    return _list => _indexOf(valueToFind, _list);
   }
 
-  let index = -1;
-  const {
-    length
-  } = list;
-
-  while (++index < length) {
-    if (list[index] === valueToFind) {
-      return index;
-    }
-  }
-
-  return -1;
+  return _indexOf(valueToFind, list);
 }
 
 function baseSlice(array, start, end) {
@@ -1309,25 +1416,18 @@ function last(listOrString) {
   return listOrString[listOrString.length - 1];
 }
 
-function lastIndexOf(target, list) {
-  if (arguments.length === 1) return _list => lastIndexOf(target, _list);
-  let index = list.length;
-
-  while (--index > 0) {
-    if (equals(list[index], target)) {
-      return index;
-    }
+function lastIndexOf(valueToFind, list) {
+  if (arguments.length === 1) {
+    return _list => _lastIndexOf(valueToFind, _list);
   }
 
-  return -1;
+  return _lastIndexOf(valueToFind, list);
 }
 
 function length(x) {
-  if (!x && x !== '' || x.length === undefined) {
-    return NaN;
-  }
-
-  return x.length;
+  if (_isArray(x)) return x.length;
+  if (typeof x === 'string') return x.length;
+  return NaN;
 }
 
 function lens(getter, setter) {
@@ -1345,8 +1445,9 @@ function nth(index, list) {
 }
 
 function updateFn(index, newValue, list) {
-  const arrClone = list.slice();
-  return arrClone.fill(newValue, index, index + 1);
+  const clone = cloneList(list);
+  if (index === -1) return clone.fill(newValue, index);
+  return clone.fill(newValue, index, index + 1);
 }
 
 const update = curry(updateFn);
@@ -1359,12 +1460,6 @@ function lensPath(key) {
   return lens(path(key), assocPath(key));
 }
 
-function prop(propToFind, obj) {
-  if (arguments.length === 1) return _obj => prop(propToFind, _obj);
-  if (!obj) return undefined;
-  return obj[propToFind];
-}
-
 function lensProp(key) {
   return lens(prop(key), assoc(key));
 }
@@ -1464,7 +1559,7 @@ function moveFn(fromIndex, toIndex, list) {
   }
 
   if (fromIndex > list.length - 1 || toIndex > list.length - 1) return list;
-  const clone = list.slice();
+  const clone = cloneList(list);
   clone[fromIndex] = list[toIndex];
   clone[toIndex] = list[fromIndex];
   return clone;
@@ -1618,8 +1713,8 @@ function pathEqFn(pathToSearch, target, input) {
 
 const pathEq = curry(pathEqFn);
 
-function pathOrFn(defaultValue, list, obj) {
-  return defaultTo(defaultValue, path(list, obj));
+function pathOrFn(defaultValue, pathInput, obj) {
+  return defaultTo(defaultValue, path(pathInput, obj));
 }
 
 const pathOr = curry(pathOrFn);
@@ -1807,13 +1902,12 @@ const slice = curry(sliceFn);
 
 function sort(sortFn, list) {
   if (arguments.length === 1) return _list => sort(sortFn, _list);
-  const clone = list.slice();
-  return clone.sort(sortFn);
+  return cloneList(list).sort(sortFn);
 }
 
 function sortBy(sortFn, list) {
   if (arguments.length === 1) return _list => sortBy(sortFn, _list);
-  const clone = list.slice();
+  const clone = cloneList(list);
   return clone.sort((a, b) => {
     const aSortResult = sortFn(a);
     const bSortResult = sortFn(b);
@@ -1895,9 +1989,22 @@ function splitWhen(predicate, input) {
   return [preFound, postFound];
 }
 
-function startsWith(target, str) {
-  if (arguments.length === 1) return _str => startsWith(target, _str);
-  return str.startsWith(target);
+function startsWith(target, iterable) {
+  if (arguments.length === 1) return _iterable => startsWith(target, _iterable);
+
+  if (typeof iterable === 'string') {
+    return iterable.startsWith(target);
+  }
+
+  if (!_isArray(target)) return false;
+  let correct = true;
+  const filtered = target.filter((x, index) => {
+    if (!correct) return false;
+    const result = equals(x, iterable[index]);
+    if (!result) correct = false;
+    return result;
+  });
+  return filtered.length === target.length;
 }
 
 function subtract(a, b) {
@@ -2047,15 +2154,36 @@ function tryCatch(fn, fallback) {
   };
 }
 
+function unapply(fn) {
+  return function (...args) {
+    return fn.call(this, args);
+  };
+}
+
 function union(x, y) {
   if (arguments.length === 1) return _y => union(x, _y);
-  const toReturn = x.slice();
+  const toReturn = cloneList(x);
   y.forEach(yInstance => {
     if (!includes(yInstance, x)) toReturn.push(yInstance);
   });
   return toReturn;
 }
 
+function includesWith(predicate, target, list) {
+  let willReturn = false;
+  let index = -1;
+
+  while (++index < list.length && !willReturn) {
+    const value = list[index];
+
+    if (predicate(target, value)) {
+      willReturn = true;
+    }
+  }
+
+  return willReturn;
+}
+
 function uniqWith(predicate, list) {
   if (arguments.length === 1) return _list => uniqWith(predicate, _list);
   let index = -1;
@@ -2063,9 +2191,8 @@ function uniqWith(predicate, list) {
 
   while (++index < list.length) {
     const value = list[index];
-    const flag = any(x => predicate(value, x), willReturn);
 
-    if (!flag) {
+    if (!includesWith(predicate, value, willReturn)) {
       willReturn.push(value);
     }
   }
@@ -2135,7 +2262,7 @@ function without(matchAgainst, source) {
     return _source => without(matchAgainst, _source);
   }
 
-  return reduce((prev, current) => includesArray(current, matchAgainst) ? prev : prev.concat(current), [], source);
+  return reduce((prev, current) => _indexOf(current, matchAgainst) > -1 ? prev : prev.concat(current), [], source);
 }
 
 function xor(a, b) {
@@ -2171,6 +2298,8 @@ const zipWith = curry(zipWithFn);
 
 exports.F = F;
 exports.T = T;
+exports._indexOf = _indexOf;
+exports._lastIndexOf = _lastIndexOf;
 exports.add = add;
 exports.adjust = adjust;
 exports.all = all;
@@ -2180,9 +2309,11 @@ exports.and = and;
 exports.any = any;
 exports.anyPass = anyPass;
 exports.append = append;
+exports.apply = apply;
 exports.applySpec = applySpec;
 exports.assoc = assoc;
 exports.assocPath = assocPath;
+exports.bind = bind;
 exports.both = both;
 exports.chain = chain;
 exports.clamp = clamp;
@@ -2233,7 +2364,6 @@ exports.identity = identity;
 exports.ifElse = ifElse;
 exports.inc = inc;
 exports.includes = includes;
-exports.includesArray = includesArray;
 exports.indexBy = indexBy;
 exports.indexOf = indexOf;
 exports.init = init;
@@ -2335,6 +2465,7 @@ exports.transpose = transpose;
 exports.trim = trim;
 exports.tryCatch = tryCatch;
 exports.type = type;
+exports.unapply = unapply;
 exports.union = union;
 exports.uniq = uniq;
 exports.uniqWith = uniqWith;