rambda 10.0.0-alpha.0 → 10.0.0-beta.3

package/dist/rambda.umd.js

@@ -4,6 +4,39 @@
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.R = {}));
 })(this, (function (exports) { 'use strict';
 
+  function addProp(key, value) {
+    return obj => ({ ...obj, [key]: value })
+  }
+
+  function mapFn(
+  	fn, list
+  ){
+  	let index = 0;
+  	const willReturn = Array(list.length);
+  	while (index < list.length) {
+  		willReturn[index] = fn(list[index], index);
+  		index++;
+  	}
+  	return willReturn
+  }
+
+  function map(fn) {
+    return list => mapFn(fn, list)
+  }
+
+  function addPropToObjects (
+  	property, 
+  	fn
+  ){
+  	return listOfObjects => mapFn(
+  		(obj) => ({
+  			...(obj),
+  			[property]: fn(obj)
+  		}), 
+  		listOfObjects
+  	)
+  }
+
   function all(predicate) {
     return list => {
       for (let i = 0; i < list.length; i++) {
@@ -58,15 +91,32 @@
     }
   }
 
-  const cloneList = list => Array.prototype.slice.call(list);
+  const cloneList$1 = list => Array.prototype.slice.call(list);
 
   function append(x) {
-    return list=> {
-  		const clone = cloneList(list);
-    clone.push(x);
+    return list => {
+      const clone = cloneList$1(list);
+      clone.push(x);
 
-    return clone
-  	}
+      return clone
+    }
+  }
+
+  function createCompareFunction(a, b, winner, loser) {
+    if (a === b) {
+      return 0
+    }
+
+    return a < b ? winner : loser
+  }
+
+  function ascend(getFunction) {
+  	return (a, b) => {
+    const aValue = getFunction(a);
+    const bValue = getFunction(b);
+
+    return createCompareFunction(aValue, bValue, -1, 1)
+  }
   }
 
   function checkObjectWithSpec(conditions) {
@@ -86,67 +136,125 @@
     }
   }
 
+  const { isArray } = Array;
+
+  function filter(predicate) {
+    return list => {
+      if (!list) {
+        throw new Error('Incorrect iterable input')
+      }
+      let index = 0;
+      const len = list.length;
+      const willReturn = [];
+
+      while (index < len) {
+        if (predicate(list[index], index)) {
+          willReturn.push(list[index]);
+        }
+
+        index++;
+      }
+
+      return willReturn
+    }
+  }
+
+  function reject(predicate) {
+    return list => filter(x => !predicate(x))(list)
+  }
+
+  function rejectObject(predicate) {
+    return obj => {
+      const willReturn = {};
+
+      for (const prop in obj) {
+        if (!predicate(obj[prop], prop, obj)) {
+          willReturn[prop] = obj[prop];
+        }
+      }
+
+      return willReturn
+    }
+  }
+
+  const isNullOrUndefined = x => x === null || x === undefined;
+
+  function compact(input){
+  	if(isArray(input)){
+  		return reject(isNullOrUndefined)(input)
+  	}
+  	return rejectObject(isNullOrUndefined)(input)
+  }
+
   function complement(fn) {
     return (...input) => !fn(...input)
   }
 
   function concat(x) {
-    return y => typeof x === 'string' ? `${x}${y}` : [...x, ...y]
+    return y => (typeof x === 'string' ? `${x}${y}` : [...x, ...y])
   }
 
-  const { isArray } = Array;
+  function count(predicate) {
+    return list => {
+      if (!isArray(list)) {
+        return 0
+      }
 
-  function count(predicate, ) {
-   return list => {
-    if (!isArray(list)) {
-      return 0
+      return list.filter(x => predicate(x)).length
     }
-
-    return list.filter(x => predicate(x)).length
-  }
   }
 
   function countBy(fn) {
-  	return list => {
-    const willReturn = {};
+    return list => {
+      const willReturn = {};
 
-    list.forEach(item => {
-      const key = fn(item);
-      if (!willReturn[key]) {
-        willReturn[key] = 1;
-      } else {
-        willReturn[key]++;
-      }
-    });
+      list.forEach(item => {
+        const key = fn(item);
+        if (!willReturn[key]) {
+          willReturn[key] = 1;
+        } else {
+          willReturn[key]++;
+        }
+      });
 
-    return willReturn
+      return willReturn
+    }
   }
+
+  function createObjectFromKeys(keys) {
+  	return fn => {
+  		const result = {};
+  		keys.forEach((key, index) => {
+  			result[key] = fn(key, index);
+  		});
+
+  		return result
+  	}
   }
 
   function isFalsy(input) {
     return input === undefined || input === null || Number.isNaN(input) === true
   }
 
-  function defaultTo(defaultArgument, input) {
-    if (arguments.length === 1) {
-      return _input => defaultTo(defaultArgument, _input)
-    }
-
-    return isFalsy(input) ? defaultArgument : input
+  function defaultTo(defaultArgument) {
+    return input => isFalsy(input) ? defaultArgument : input
   }
 
-  function drop(howManyToDrop, listOrString) {
-    if (arguments.length === 1) {
-      return _list => drop(howManyToDrop, _list)
+  function descend(getFunction) {
+    return (a, b) => {
+      const aValue = getFunction(a);
+      const bValue = getFunction(b);
+
+      return createCompareFunction(aValue, bValue, 1, -1)
     }
+  }
 
-    return listOrString.slice(howManyToDrop > 0 ? howManyToDrop : 0)
+  function drop(howManyToDrop, ) {
+    return list => list.slice(howManyToDrop > 0 ? howManyToDrop : 0)
   }
 
   function dropLast(numberItems) {
-  	return list => numberItems > 0
-      ? list.slice(0, -numberItems)
-      : list.slice()
+    return list => (numberItems > 0 ? list.slice(0, -numberItems) : list.slice())
   }
 
   function dropLastWhile(predicate) {
@@ -306,7 +414,7 @@
   }
 
   function equalsFn(a, b) {
-  	if (Object.is(a, b)) {
+    if (Object.is(a, b)) {
       return true
     }
 
@@ -415,19 +523,15 @@
     return false
   }
   function equals(a) {
-  	return b => equalsFn(a, b)
+    return b => equalsFn(a, b)
   }
 
   function eqBy(fn, a) {
     return b => equalsFn(fn(a), fn(b))
   }
 
-  function prop(searchProperty) {
-    return obj => (obj ? obj[searchProperty] : undefined)
-  }
-
   function eqProps(property, objA) {
-    return objB => equalsFn(prop(property)(objA), prop(property)(objB))
+    return objB => equalsFn( objA[property], objB[property] )
   }
 
   const { keys } = Object;
@@ -449,73 +553,30 @@
     }
   }
 
-  function evolveFn(rules, obj) {
-      return mapObject((x, prop) => {
-        if (type(x) === 'Object') {
-          const typeRule = type(rules[prop]);
-          if (typeRule === 'Function') {
-            return rules[prop](x)
-          }
-          if (typeRule === 'Object') {
-            return evolveFn(rules[prop], x)
-          }
-
-          return x
-        }
-        if (type(rules[prop]) === 'Function') {
-          return rules[prop](x)
-        }
-
-        return x
-      })(obj)
-  }
-
   function evolve(rules) {
-    return obj =>	evolveFn(rules, obj)
-  		}
+    return mapObject((x, prop) => type(rules[prop]) === 'Function' ? rules[prop](x): x)
+  }
 
   function includes(valueToFind) {
-  	return iterable => 
-  	{
-    if (typeof iterable === 'string') {
-      return iterable.includes(valueToFind)
-    }
-    if (!iterable) {
-      throw new TypeError(`Cannot read property \'indexOf\' of ${iterable}`)
-    }
-    if (!isArray(iterable)) {
-      return false
-    }
+    return iterable => {
+      if (typeof iterable === 'string') {
+        return iterable.includes(valueToFind)
+      }
+      if (!iterable) {
+        throw new TypeError(`Cannot read property \'indexOf\' of ${iterable}`)
+      }
+      if (!isArray(iterable)) {
+        return false
+      }
 
-    return _indexOf(valueToFind, iterable) > -1
-  }
+      return _indexOf(valueToFind, iterable) > -1
+    }
   }
 
   function excludes(valueToFind) {
     return iterable => !includes(valueToFind)(iterable)
   }
 
-  function filter(predicate) {
-  	return list => {
-    if (!list) {
-      throw new Error('Incorrect iterable input')
-    }
-  	let index = 0;
-    const len = list.length;
-    const willReturn = [];
-
-    while (index < len) {
-      if (predicate(list[index], index)) {
-        willReturn.push(list[index]);
-      }
-
-      index++;
-    }
-  	
-    return willReturn
-  	}
-  }
-
   function filterObject(predicate) {
     return obj => {
       const willReturn = {};
@@ -531,62 +592,79 @@
   }
 
   function find(predicate) {
-  	return list => {
-    let index = 0;
-    const len = list.length;
+    return list => {
+      let index = 0;
+      const len = list.length;
 
-    while (index < len) {
-      const x = list[index];
-      if (predicate(x)) {
-        return x
-      }
+      while (index < len) {
+        const x = list[index];
+        if (predicate(x)) {
+          return x
+        }
 
-      index++;
+        index++;
+      }
     }
   }
-  }
 
   function findIndex(predicate) {
-  	return list => {
-    const len = list.length;
-    let index = -1;
+    return list => {
+      const len = list.length;
+      let index = -1;
 
-    while (++index < len) {
-      if (predicate(list[index])) {
-        return index
+      while (++index < len) {
+        if (predicate(list[index])) {
+          return index
+        }
       }
-    }
 
-    return -1
-  }
+      return -1
+    }
   }
 
   function findLast(predicate) {
-  	return list => {
-    let index = list.length;
+    return list => {
+      let index = list.length;
 
-    while (--index >= 0) {
-      if (predicate(list[index])) {
-        return list[index]
+      while (--index >= 0) {
+        if (predicate(list[index])) {
+          return list[index]
+        }
       }
-    }
 
-    return undefined
-  }
+      return undefined
+    }
   }
 
   function findLastIndex(fn) {
-  	return list => {
-    let index = list.length;
+    return list => {
+      let index = list.length;
 
-    while (--index >= 0) {
-      if (fn(list[index])) {
-        return index
+      while (--index >= 0) {
+        if (fn(list[index])) {
+          return index
+        }
       }
-    }
 
-    return -1
+      return -1
+    }
   }
+
+  function findNth(predicate, nth) {
+    return list => {
+      let index = 0;
+      const len = list.length;
+
+      while (index < len) {
+        const x = list[index];
+        if (predicate(x)) {
+  				if (nth === 0) return x
+  				nth--;
+        }
+
+        index++;
+      }
+    }
   }
 
   function flatMap(fn) {
@@ -607,24 +685,100 @@
     return willReturn
   }
 
-  function groupBy(groupFn, list) {
-    if (arguments.length === 1) {
-      return _list => groupBy(groupFn, _list)
-    }
+  function flattenObjectHelper(obj, accumulator = []){
+    const willReturn = {};
+    Object.keys(obj).forEach(key => {
+      const typeIs = type(obj[ key ]);
+      if (typeIs === 'Object'){
+        const [ flatResultValue, flatResultPath ] = flattenObjectHelper(obj[ key ],
+          [ ...accumulator, key ]);
+        willReturn[ flatResultPath.join('.') ] = flatResultValue;
 
-    const result = {};
-    for (let i = 0; i < list.length; i++) {
-      const item = list[i];
-      const key = groupFn(item);
+        return
+      } else if (accumulator.length > 0){
+        const finalKey = [ ...accumulator, key ].join('.');
+        willReturn[ finalKey ] = obj[ key ];
 
-      if (!result[key]) {
-        result[key] = [];
+        return
       }
+      willReturn[ key ] = obj[ key ];
+    });
+    if (accumulator.length > 0) return [ willReturn, accumulator ]
 
-      result[key].push(item);
-    }
+    return willReturn
+  }
 
-    return result
+  function transformFlatObject(obj){
+    const willReturn = {};
+
+    const transformFlatObjectFn = objLocal => {
+      const willReturnLocal = {};
+      Object.keys(objLocal).forEach(key => {
+        const typeIs = type(objLocal[ key ]);
+        if (typeIs === 'Object'){
+          transformFlatObjectFn(objLocal[ key ]);
+
+          return
+        }
+        willReturnLocal[ key ] = objLocal[ key ];
+        willReturn[ key ] = objLocal[ key ];
+      });
+
+      return willReturnLocal
+    };
+
+    Object.keys(obj).forEach(key => {
+      const typeIs = type(obj[ key ]);
+      if (typeIs === 'Object'){
+        transformFlatObjectFn(obj[ key ]);
+
+        return
+      }
+      willReturn[ key ] = obj[ key ];
+    });
+
+    return willReturn
+  }
+
+  function flattenObject(obj){
+    const willReturn = {};
+
+    Object.keys(obj).forEach(key => {
+      const typeIs = type(obj[ key ]);
+      if (typeIs === 'Object'){
+        const flatObject = flattenObjectHelper(obj[ key ]);
+        const transformed = transformFlatObject(flatObject);
+
+        Object.keys(transformed).forEach(keyTransformed => {
+          willReturn[ `${ key }.${ keyTransformed }` ] = transformed[ keyTransformed ];
+        });
+      } else {
+        willReturn[ key ] = obj[ key ];
+      }
+    });
+
+    return willReturn
+  }
+
+  function groupByFallback(groupFn, list) {
+      const result = {};
+      for (let i = 0; i < list.length; i++) {
+        const item = list[i];
+        const key = groupFn(item);
+
+        if (!result[key]) {
+          result[key] = [];
+        }
+
+        result[key].push(item);
+      }
+
+      return result
+  }
+
+
+  function groupBy(groupFn) {
+    return iterable => Object.groupBy ? Object.groupBy(iterable,groupFn) : groupByFallback(groupFn, iterable)
   }
 
   function head(listOrString) {
@@ -701,30 +855,60 @@
     return ys => _filter(x => _includesWith(pred, x, ys), xs)
   }
 
+  const getOccurrences = input => input.match(/{{\s*.+?\s*}}/g);
+  const getOccurrenceProp = occurrence => occurrence.replace(/{{\s*|\s*}}/g, '');
+
+  const replace$1 = ({ inputHolder, prop, replacer }) => {
+    const regexBase = `{{${prop}}}`;
+    const regex = new RegExp(regexBase, 'g');
+    return inputHolder.replace(regex, replacer)
+  };
+
+  function interpolate(input) {
+    return templateInput => {
+      const occurrences = getOccurrences(input);
+      if (occurrences === null) {
+        return input
+      }
+      let inputHolder = input;
+
+      for (const occurrence of occurrences) {
+        const prop = getOccurrenceProp(occurrence);
+        inputHolder = replace$1({
+          inputHolder,
+          prop,
+          replacer: templateInput[prop],
+        });
+      }
+
+      return inputHolder
+    }
+  }
+
   function intersection(listA) {
-    return listB =>filter(x => includes(x)(listA))(listB)
+    return listB => filter(x => includes(x)(listA))(listB)
   }
 
   function intersperse(separator) {
-  	return list => {
-    let index = -1;
-    const len = list.length;
-    const willReturn = [];
+    return list => {
+      let index = -1;
+      const len = list.length;
+      const willReturn = [];
 
-    while (++index < len) {
-      if (index === len - 1) {
-        willReturn.push(list[index]);
-      } else {
-        willReturn.push(list[index], separator);
+      while (++index < len) {
+        if (index === len - 1) {
+          willReturn.push(list[index]);
+        } else {
+          willReturn.push(list[index], separator);
+        }
       }
-    }
 
-    return willReturn
-  }
+      return willReturn
+    }
   }
 
   function join(glue) {
-    return list=> list.join(glue)
+    return list => list.join(glue)
   }
 
   function last(listOrString) {
@@ -739,47 +923,51 @@
     return list => _lastIndexOf(valueToFind, list)
   }
 
-  function map(fn) {
-    return list => {
-      let index = 0;
-      const willReturn = Array(list.length);
-      while (index < list.length) {
-        willReturn[index] = fn(list[index], index);
-        index++;
-      }
-      return willReturn
-    }
-  }
-
   function mapAsync(fn) {
-  	return async list => {
-  		const willReturn = [];
+    return async list => {
+      const willReturn = [];
       let i = 0;
       for (const a of list) {
         willReturn.push(await fn(a, i++));
       }
 
       return willReturn
-  	}
+    }
   }
 
-  function mapObjectAsync(fn) {
-  	return async obj => {
+  function mapKeys(fn) {
+    return obj => {
   		const willReturn = {};
-  		for (const prop in obj){
-  			willReturn[ prop ] = await fn(obj[ prop ], prop);
-  		}
-  	
+
+  		Object.keys(obj).forEach(key => {
+  			willReturn[fn(key, obj[key])] = obj[key];
+  		});
+
   		return willReturn
   	}
   }
 
+  function mapObjectAsync(fn) {
+    return async obj => {
+      const willReturn = {};
+      for (const prop in obj) {
+        willReturn[prop] = await fn(obj[prop], prop);
+      }
+
+      return willReturn
+    }
+  }
+
+  function mapParallelAsync(fn) {
+    return async list =>  Promise.all(list.map((x, i) => fn(x, i)))
+  }
+
   function match(pattern) {
-  	return input => {
-  		const willReturn = input.match(pattern);
-  	
-  		return willReturn === null ? [] : willReturn
-  	}
+    return input => {
+      const willReturn = input.match(pattern);
+
+      return willReturn === null ? [] : willReturn
+    }
   }
 
   function maxBy(compareFn, x) {
@@ -799,66 +987,47 @@
     return y => (compareFn(y) < compareFn(x) ? y : x)
   }
 
-  function createPath(path, delimiter = '.') {
-    return typeof path === 'string'
-      ? path.split(delimiter).map(x => (Number.isInteger(Number(x)) ? Number(x) : x))
-      : path
-  }
+  function modifyItemAtIndex(index, replaceFn) {
+    return list => {
+      const actualIndex = index < 0 ? list.length + index : index;
+      if (index >= list.length || actualIndex < 0) {
+        return list
+      }
 
-  function path(pathInput, obj) {
-    if (arguments.length === 1) {
-      return _obj => path(pathInput, _obj)
-    }
+      const clone = cloneList$1(list);
+      clone[actualIndex] = replaceFn(clone[actualIndex]);
 
-    if (!obj) {
-      return undefined
+      return clone
     }
-    let willReturn = obj;
-    let counter = 0;
-
-    const pathArrValue = createPath(pathInput);
+  }
 
-    while (counter < pathArrValue.length) {
-      if (willReturn === null || willReturn === undefined) {
-        return undefined
-      }
-      if (willReturn[pathArrValue[counter]] === null) {
-        return undefined
+  function update(index, newValue) {
+    return list => {
+      const clone = cloneList$1(list);
+      if (index === -1) {
+        return clone.fill(newValue, index)
       }
 
-      willReturn = willReturn[pathArrValue[counter]];
-      counter++;
+      return clone.fill(newValue, index, index + 1)
     }
-
-    return willReturn
   }
 
-  function assoc(prop, newValue) {
-    return obj => Object.assign({}, obj, { [prop]: newValue })
-  }
-
-  function modifyPathFn(pathInput, fn, obj) {
-      const path$1 = createPath(pathInput);
-      if (path$1.length === 1) {
-        return {
-          ...obj,
-          [path$1[0]]: fn(obj[path$1[0]]),
-        }
-      }
-      if (path(path$1)(obj) === undefined) {
-        return obj
-      }
-
-      const val = modifyPathFn(Array.prototype.slice.call(path$1, 1), fn, obj[path$1[0]]);
-      if (val === obj[path$1[0]]) {
-        return obj
-      }
+  function modifyFn(property, fn, list) {
+    if (list[property] === undefined) {
+      return list
+    }
+    if (isArray(list)) {
+      return update(property, fn(list[property]))(list)
+    }
 
-      return assoc(path$1[0], val)(obj)
+    return {
+      ...list,
+      [property]: fn(list[property]),
+    }
   }
 
-  function modifyPath(pathInput, fn) {
-    return obj => modifyPathFn(pathInput, fn, obj)
+  function modifyProp(property, fn) {
+    return obj => modifyFn(property, fn, obj)
   }
 
   function none(predicate) {
@@ -877,6 +1046,22 @@
     return value => ({ [key]: value })
   }
 
+  function objectIncludes(condition) {
+    return obj => {
+      const result = filterObject((conditionValue, conditionProp) =>
+        equals(conditionValue)(obj[conditionProp]),
+      )(condition);
+
+      return Object.keys(result).length === Object.keys(condition).length
+    }
+  }
+
+  function createPath(path, delimiter = '.') {
+    return typeof path === 'string'
+      ? path.split(delimiter).map(x => (Number.isInteger(Number(x)) ? Number(x) : x))
+      : path
+  }
+
   function _includes(x, list) {
     let index = -1;
     const { length } = list;
@@ -909,10 +1094,29 @@
     }
   }
 
-  function partitionObject(predicate, iterable) {
+  function partition(predicate) {
+    return list => {
+  		const yes = [];
+  		const no = [];
+  		let counter = -1;
+  	
+  		while (counter++ < list.length - 1) {
+  			if (predicate(list[counter], counter)) {
+  				yes.push(list[counter]);
+  			} else {
+  				no.push(list[counter]);
+  			}
+  		}
+  	
+  		return [yes, no]
+    }
+  }
+
+  function partitionObject(predicate) {
+  	return obj => {
     const yes = {};
     const no = {};
-    Object.entries(iterable).forEach(([prop, value]) => {
+    Object.entries(obj).forEach(([prop, value]) => {
       if (predicate(value, prop)) {
         yes[prop] = value;
       } else {
@@ -922,31 +1126,75 @@
 
     return [yes, no]
   }
+  }
 
-  function partitionArray(predicate, list, indexed = false) {
-    const yes = [];
-    const no = [];
-    let counter = -1;
+  function path(pathInput) {
+  	return (obj)  => {
+  		if (!obj) {
+  			return undefined
+  		}
+  		let willReturn = obj;
+  		let counter = 0;
+  	
+  		const pathArrValue = createPath(pathInput);
+  	
+  		while (counter < pathArrValue.length) {
+  			if (willReturn === null || willReturn === undefined) {
+  				return undefined
+  			}
+  			if (willReturn[pathArrValue[counter]] === null) {
+  				return undefined
+  			}
+  	
+  			willReturn = willReturn[pathArrValue[counter]];
+  			counter++;
+  		}
+  	
+  		return willReturn
+  	}
+  }
+
+  function pathSatisfies(fn, pathInput) {
+    return obj => Boolean(fn(path(pathInput)(obj)))
+  }
+
+  /**
+   * Source:
+   * https://github.com/denoland/std/blob/main/collections/permutations.ts
+   */
+  function permutations(inputArray) {
+    const result = [];
+    const array = cloneList$1(inputArray);
+    const k = array.length;
+    if (k === 0) {
+      return result;
+    }
+
+    const c = new Array(k).fill(0);
+
+    result.push([...array]);
+
+    let i = 1;
+
+    while (i < k) {
+      if (c[i] < i) {
+        if (i % 2 === 0) {
+          [array[0], array[i]] = [array[i], array[0]];
+        } else {
+          [array[c[i]], array[i]] = [array[i], array[c[i]]];
+        }
 
-    while (counter++ < list.length - 1) {
-      if (indexed ? predicate(list[counter], counter) : predicate(list[counter])) {
-        yes.push(list[counter]);
+        result.push([...array]);
+
+        c[i] += 1;
+        i = 1;
       } else {
-        no.push(list[counter]);
+        c[i] = 0;
+        i += 1;
       }
     }
 
-    return [yes, no]
-  }
-
-  function partition(predicate) {
-  	return iterable => {
-  		if (!isArray(iterable)) {
-  			return partitionObject(predicate, iterable)
-  		}
-  	
-  		return partitionArray(predicate, iterable)
-  	}
+    return result;
   }
 
   function pick(propsToPick) {
@@ -1069,30 +1317,35 @@
   }
 
   async function pipeAsync(input, ...fnList) {
-  		let willReturn = input;
-  		for (const fn of fnList) {
-  			const initialResult = fn(willReturn);
-  			willReturn = type(initialResult) === 'Promise' ? await initialResult : initialResult;
-      }
-  		return willReturn
+    let willReturn = input;
+    for (const fn of fnList) {
+      const initialResult = fn(willReturn);
+      willReturn =
+        type(initialResult) === 'Promise' ? await initialResult : initialResult;
+    }
+    return willReturn
   }
 
   function pluck(property) {
-  	return list => {
-    const willReturn = [];
+    return list => {
+      const willReturn = [];
 
-    list.forEach(x => {
-      if (x[property] !== undefined) {
-        willReturn.push(x[property]);
-      }
-    });
+      list.forEach(x => {
+        if (x[property] !== undefined) {
+          willReturn.push(x[property]);
+        }
+      });
 
-    return willReturn
-  }
+      return willReturn
+    }
   }
 
   function prepend(x) {
-    return list=> [x].concat(list)
+    return list => [x].concat(list)
+  }
+
+  function prop(searchProperty) {
+    return obj => (obj ? obj[searchProperty] : undefined)
   }
 
   function propEq(valueToMatch, propToFind) {
@@ -1111,72 +1364,119 @@
         return defaultValue
       }
 
-      return defaultTo(defaultValue, obj[property])
+      return defaultTo(defaultValue)(obj[property])
     }
   }
 
   function propSatisfies(predicate, property) {
-    return obj => predicate(prop(property))
+    return obj => predicate(obj[property])
   }
 
-  function range(start){
-  	return end => {
-    if (Number.isNaN(Number(start)) || Number.isNaN(Number(end))){
-      throw new TypeError('Both arguments to range must be numbers')
-    }
+  function rangeDescending(start, end) {
+  	const len = start - end;
+  	const willReturn = Array(len);
+
+  	for (let i = 0; i < len; i++) {
+  		willReturn[i] = start - i;
+  	}
 
-    if (end < start) return []
+  	return willReturn
+  }
 
-    const len = end - start;
-    const willReturn = Array(len);
+  function range(start) {
+    return end => {
+      if (Number.isNaN(Number(start)) || Number.isNaN(Number(end))) {
+        throw new TypeError('Both arguments to range must be numbers')
+      }
 
-    for (let i = 0; i < len; i++){
-      willReturn[ i ] = start + i;
-    }
+      if (end === start) {
+        return []
+      }
+  		if (end < start) return rangeDescending(start,end)
 
-    return willReturn
-  }
-  }
+      const len = end - start;
+      const willReturn = Array(len);
 
-  function reject(predicate) {
-    return list => filter(x => !predicate(x))
+      for (let i = 0; i < len; i++) {
+        willReturn[i] = start + i;
+      }
+
+      return willReturn
+    }
   }
 
   function replace(pattern, replacer) {
     return str => str.replace(pattern, replacer)
   }
 
-  function replaceItemAtIndex(index, replaceFn) {
-    return list => {
-      const actualIndex = index < 0 ? list.length + index : index;
-      if (index >= list.length || actualIndex < 0) {
-        return list
-      }
+  function shuffle(listInput) {
+    const list = cloneList(listInput);
+    let counter = list.length;
+    while (counter > 0) {
+      const index = Math.floor(Math.random() * counter);
+      counter--;
+      const temp = list[counter];
+      list[counter] = list[index];
+      list[index] = temp;
+    }
 
-      const clone = cloneList(list);
-      clone[actualIndex] = replaceFn(clone[actualIndex]);
+    return list
+  }
 
-      return clone
-    }
+  function sort(sortFn) {
+    return list => cloneList$1(list).sort(sortFn)
   }
 
-  function sort(sortFn){
-    return list => cloneList(list).sort(sortFn)
+  function sortByFn (
+  	sortFn,
+  	list,
+  	descending
+  ){
+  	const clone = cloneList$1(list);
+
+  	return clone.sort((a, b) => {
+  		const aSortResult = sortFn(a);
+  		const bSortResult = sortFn(b);
+
+  		if (aSortResult === bSortResult) {
+  			return 0
+  		}
+  		if(
+  			descending
+  		) return aSortResult > bSortResult ? -1 : 1
+
+  		return aSortResult < bSortResult ? -1 : 1
+  	})
   }
 
-  function sortBy(sortFn){
-  	return list => {
-    const clone = cloneList(list);
+  function sortBy(sortFn) {
+    return list => sortByFn(sortFn, list, false)
+  }
 
-    return clone.sort((a, b) => {
-      const aSortResult = sortFn(a);
-      const bSortResult = sortFn(b);
+  function sortByDescending(sortFn) {
+    return list => sortByFn(sortFn, list, true)
+  }
 
-      if (aSortResult === bSortResult) return 0
+  function sortByPath(sortPath) {
+    return list => sortBy(path(sortPath))(list)
+  }
 
-      return aSortResult < bSortResult ? -1 : 1
-    })
+  function sortByPathDescending(sortPath) {
+    return list => sortByDescending(path(sortPath))(list)
   }
+
+  function sortObject(predicate) {
+    return obj => {
+      const keys = Object.keys(obj);
+      const sortedKeys = sort((a, b) => predicate(a, b, obj[a], obj[b]))(keys);
+
+      const toReturn = {};
+      sortedKeys.forEach(singleKey => {
+        toReturn[singleKey] = obj[singleKey];
+      });
+
+      return toReturn
+    }
   }
 
   function sortHelper(a, b, listOfSortingFns) {
@@ -1191,37 +1491,37 @@
   }
 
   function sortWith(listOfSortingFns) {
-  	return list => {
-    if (Array.isArray(list) === false) {
-      return []
-    }
+    return list => {
+      if (Array.isArray(list) === false) {
+        return []
+      }
 
-    const clone = list.slice();
-    clone.sort((a, b) => sortHelper(a, b, listOfSortingFns));
+      const clone = list.slice();
+      clone.sort((a, b) => sortHelper(a, b, listOfSortingFns));
 
-    return clone
-  }
+      return clone
+    }
   }
 
-  function split(separator){
-  	return str => str.split(separator)
+  function split(separator) {
+    return str => str.split(separator)
   }
 
   function splitEvery(sliceLength) {
-  	return list => {
-    if (sliceLength < 1) {
-      throw new Error('First argument to splitEvery must be a positive integer')
-    }
+    return list => {
+      if (sliceLength < 1) {
+        throw new Error('First argument to splitEvery must be a positive integer')
+      }
 
-    const willReturn = [];
-    let counter = 0;
+      const willReturn = [];
+      let counter = 0;
 
-    while (counter < list.length) {
-      willReturn.push(list.slice(counter, (counter += sliceLength)));
-    }
+      while (counter < list.length) {
+        willReturn.push(list.slice(counter, (counter += sliceLength)));
+      }
 
-    return willReturn
-  }
+      return willReturn
+    }
   }
 
   function symmetricDifference(x) {
@@ -1267,24 +1567,24 @@
   }
 
   function takeLastWhile(predicate) {
-  	return input => {
-  		if (input.length === 0) {
-  			return input
-  		}
-  	
-  		const toReturn = [];
-  		let counter = input.length;
-  	
-  		while (counter) {
-  			const item = input[--counter];
-  			if (!predicate(item)) {
-  				break
-  			}
-  			toReturn.push(item);
-  		}
-  	
-  		return toReturn.reverse() 
-  	}
+    return input => {
+      if (input.length === 0) {
+        return input
+      }
+
+      const toReturn = [];
+      let counter = input.length;
+
+      while (counter) {
+        const item = input[--counter];
+        if (!predicate(item)) {
+          break
+        }
+        toReturn.push(item);
+      }
+
+      return toReturn.reverse()
+    }
   }
 
   function takeWhile(predicate) {
@@ -1304,15 +1604,15 @@
   }
 
   function tap(fn) {
-  	return x => {
-    fn(x);
+    return x => {
+      fn(x);
 
-    return x
-  }
+      return x
+    }
   }
 
   function test(pattern) {
-  	return str => str.search(pattern) !== -1
+    return str => str.search(pattern) !== -1
   }
 
   function tryCatch(fn, fallback) {
@@ -1327,7 +1627,7 @@
 
   function union(x) {
     return y => {
-      const toReturn = cloneList(x);
+      const toReturn = cloneList$1(x);
 
       y.forEach(yInstance => {
         if (!includes(yInstance)(x)) {
@@ -1391,11 +1691,11 @@
   }
 
   function uniqBy(fn) {
-  	return list => {
-  		const set = new _Set();
+    return list => {
+      const set = new _Set();
 
-  		return list.filter(item => set.checkUniqueness(fn(item)))
-  	}
+      return list.filter(item => set.checkUniqueness(fn(item)))
+    }
   }
 
   function includesWith(predicate, target, list) {
@@ -1414,20 +1714,20 @@
   }
 
   function uniqWith(predicate) {
-  	return list => {
-    let index = -1;
-    const willReturn = [];
+    return list => {
+      let index = -1;
+      const willReturn = [];
 
-    while (++index < list.length) {
-      const value = list[index];
+      while (++index < list.length) {
+        const value = list[index];
 
-      if (!includesWith(predicate, value, willReturn)) {
-        willReturn.push(value);
+        if (!includesWith(predicate, value, willReturn)) {
+          willReturn.push(value);
+        }
       }
-    }
 
-    return willReturn
-  }
+      return willReturn
+    }
   }
 
   function unless(predicate, whenFalseFn) {
@@ -1449,17 +1749,6 @@
     }
   }
 
-  function update(index, newValue) {
-    return list => {
-      const clone = cloneList(list);
-      if (index === -1) {
-        return clone.fill(newValue, index)
-      }
-
-      return clone.fill(newValue, index, index + 1)
-    }
-  }
-
   function when(predicate, whenTrueFn) {
     return input => {
       if (!predicate(input)) {
@@ -1494,17 +1783,24 @@
   exports._includes = _includes;
   exports._indexOf = _indexOf;
   exports._lastIndexOf = _lastIndexOf;
+  exports.addProp = addProp;
+  exports.addPropToObjects = addPropToObjects;
   exports.all = all;
   exports.allPass = allPass;
   exports.any = any;
   exports.anyPass = anyPass;
   exports.append = append;
+  exports.ascend = ascend;
   exports.checkObjectWithSpec = checkObjectWithSpec;
+  exports.compact = compact;
   exports.complement = complement;
   exports.concat = concat;
   exports.count = count;
   exports.countBy = countBy;
+  exports.createCompareFunction = createCompareFunction;
+  exports.createObjectFromKeys = createObjectFromKeys;
   exports.defaultTo = defaultTo;
+  exports.descend = descend;
   exports.drop = drop;
   exports.dropLast = dropLast;
   exports.dropLastWhile = dropLastWhile;
@@ -1514,7 +1810,6 @@
   exports.equals = equals;
   exports.equalsFn = equalsFn;
   exports.evolve = evolve;
-  exports.evolveFn = evolveFn;
   exports.excludes = excludes;
   exports.filter = filter;
   exports.filterObject = filterObject;
@@ -1522,14 +1817,19 @@
   exports.findIndex = findIndex;
   exports.findLast = findLast;
   exports.findLastIndex = findLastIndex;
+  exports.findNth = findNth;
   exports.flatMap = flatMap;
   exports.flatten = flatten;
+  exports.flattenObject = flattenObject;
+  exports.flattenObjectHelper = flattenObjectHelper;
   exports.groupBy = groupBy;
+  exports.groupByFallback = groupByFallback;
   exports.head = head;
   exports.includes = includes;
   exports.indexOf = indexOf;
   exports.init = init;
   exports.innerJoin = innerJoin;
+  exports.interpolate = interpolate;
   exports.intersection = intersection;
   exports.intersperse = intersperse;
   exports.join = join;
@@ -1537,21 +1837,27 @@
   exports.lastIndexOf = lastIndexOf;
   exports.map = map;
   exports.mapAsync = mapAsync;
+  exports.mapFn = mapFn;
+  exports.mapKeys = mapKeys;
   exports.mapObject = mapObject;
   exports.mapObjectAsync = mapObjectAsync;
+  exports.mapParallelAsync = mapParallelAsync;
   exports.match = match;
   exports.maxBy = maxBy;
   exports.merge = merge;
   exports.mergeTypes = mergeTypes;
   exports.minBy = minBy;
-  exports.modifyPath = modifyPath;
+  exports.modifyItemAtIndex = modifyItemAtIndex;
+  exports.modifyProp = modifyProp;
   exports.none = none;
   exports.objOf = objOf;
+  exports.objectIncludes = objectIncludes;
   exports.omit = omit;
   exports.partition = partition;
-  exports.partitionArray = partitionArray;
   exports.partitionObject = partitionObject;
   exports.path = path;
+  exports.pathSatisfies = pathSatisfies;
+  exports.permutations = permutations;
   exports.pick = pick;
   exports.pipe = pipe;
   exports.pipeAsync = pipeAsync;
@@ -1564,10 +1870,16 @@
   exports.range = range;
   exports.reduce = reduce;
   exports.reject = reject;
+  exports.rejectObject = rejectObject;
   exports.replace = replace;
-  exports.replaceItemAtIndex = replaceItemAtIndex;
+  exports.shuffle = shuffle;
   exports.sort = sort;
   exports.sortBy = sortBy;
+  exports.sortByDescending = sortByDescending;
+  exports.sortByFn = sortByFn;
+  exports.sortByPath = sortByPath;
+  exports.sortByPathDescending = sortByPathDescending;
+  exports.sortObject = sortObject;
   exports.sortWith = sortWith;
   exports.split = split;
   exports.splitEvery = splitEvery;
@@ -1579,6 +1891,7 @@
   exports.takeWhile = takeWhile;
   exports.tap = tap;
   exports.test = test;
+  exports.transformFlatObject = transformFlatObject;
   exports.tryCatch = tryCatch;
   exports.type = type;
   exports.union = union;