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

package/src/mapKeys.js

@@ -0,0 +1,11 @@
+export function mapKeys(fn) {
+  return obj => {
+		const willReturn = {}
+
+		Object.keys(obj).forEach(key => {
+			willReturn[fn(key, obj[key])] = obj[key]
+		})
+
+		return willReturn
+	}
+}

package/src/mapObjectAsync.js

@@ -1,10 +1,10 @@
 export function mapObjectAsync(fn) {
-	return async obj => {
-		const willReturn = {}
-		for (const prop in obj){
-			willReturn[ prop ] = await fn(obj[ prop ], prop)
-		}
-	
-		return willReturn
-	}
-}
+  return async obj => {
+    const willReturn = {}
+    for (const prop in obj) {
+      willReturn[prop] = await fn(obj[prop], prop)
+    }
+
+    return willReturn
+  }
+}

package/src/mapParallelAsync.js

@@ -0,0 +1,3 @@
+export function mapParallelAsync(fn) {
+  return async list =>  Promise.all(list.map((x, i) => fn(x, i)))
+}

package/src/match.js

@@ -1,7 +1,7 @@
 export 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
+  }
 }

package/src/modifyProp.js

@@ -0,0 +1,20 @@
+import { isArray } from './_internals/isArray.js'
+import { update } from './update.js'
+
+function modifyFn(property, fn, list) {
+  if (list[property] === undefined) {
+    return list
+  }
+  if (isArray(list)) {
+    return update(property, fn(list[property]))(list)
+  }
+
+  return {
+    ...list,
+    [property]: fn(list[property]),
+  }
+}
+
+export function modifyProp(property, fn) {
+  return obj => modifyFn(property, fn, obj)
+}

package/src/objectIncludes.js

@@ -0,0 +1,12 @@
+import { equals } from './equals.js'
+import { filterObject } from './filterObject.js'
+
+export function objectIncludes(condition) {
+  return obj => {
+    const result = filterObject((conditionValue, conditionProp) =>
+      equals(conditionValue)(obj[conditionProp]),
+    )(condition)
+
+    return Object.keys(result).length === Object.keys(condition).length
+  }
+}

package/src/partition.js

@@ -1,41 +1,17 @@
-import { isArray } from './_internals/isArray.js'
-
-export function partitionObject(predicate, iterable) {
-  const yes = {}
-  const no = {}
-  Object.entries(iterable).forEach(([prop, value]) => {
-    if (predicate(value, prop)) {
-      yes[prop] = value
-    } else {
-      no[prop] = value
-    }
-  })
-
-  return [yes, no]
-}
-
-export function partitionArray(predicate, list, indexed = false) {
-  const yes = []
-  const no = []
-  let counter = -1
-
-  while (counter++ < list.length - 1) {
-    if (indexed ? predicate(list[counter], counter) : predicate(list[counter])) {
-      yes.push(list[counter])
-    } else {
-      no.push(list[counter])
-    }
-  }
-
-  return [yes, no]
-}
-
 export function partition(predicate) {
-	return iterable => {
-		if (!isArray(iterable)) {
-			return partitionObject(predicate, iterable)
+  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 partitionArray(predicate, iterable)
-	}
+		return [yes, no]
+  }
 }

package/src/partitionObject.js

@@ -0,0 +1,15 @@
+export function partitionObject(predicate) {
+	return obj => {
+  const yes = {}
+  const no = {}
+  Object.entries(obj).forEach(([prop, value]) => {
+    if (predicate(value, prop)) {
+      yes[prop] = value
+    } else {
+      no[prop] = value
+    }
+  })
+
+  return [yes, no]
+}
+}

package/src/permutations.js

@@ -0,0 +1,40 @@
+import { cloneList } from './_internals/cloneList.js'
+
+/**
+ * Source:
+ * https://github.com/denoland/std/blob/main/collections/permutations.ts
+ */
+export function permutations(inputArray) {
+  const result = [];
+  const array = cloneList(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]]]
+      }
+
+      result.push([...array]);
+
+      c[i] += 1;
+      i = 1;
+    } else {
+      c[i] = 0;
+      i += 1;
+    }
+  }
+
+  return result;
+}

package/src/pipeAsync.js

@@ -1,10 +1,11 @@
 import { type } from './type.js'
 
 export 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
 }

package/src/pluck.js

@@ -1,13 +1,13 @@
 export 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
+  }
 }

package/src/prepend.js

@@ -1,3 +1,3 @@
 export function prepend(x) {
-  return list=> [x].concat(list)
+  return list => [x].concat(list)
 }

package/src/propSatisfies.js

@@ -1,5 +1,3 @@
-import { prop } from './prop.js'
-
 export function propSatisfies(predicate, property) {
-  return obj => predicate(prop(property, obj))
+  return obj => predicate(obj[property])
 }

package/src/range.js

@@ -1,18 +1,41 @@
-export function range(start){
-	return end => {
-  if (Number.isNaN(Number(start)) || Number.isNaN(Number(end))){
-    throw new TypeError('Both arguments to range must be numbers')
-  }
+export function range(start) {
+  return end => {
+    if (Number.isNaN(Number(start)) || Number.isNaN(Number(end))) {
+      throw new TypeError('Both arguments to range must be numbers')
+    }
 
-  if (end < start) return []
+    if (end <= start) {
+      return []
+    }
 
-  const len = end - start
-  const willReturn = Array(len)
+    const len = end - start
+    const willReturn = Array(len)
 
-  for (let i = 0; i < len; i++){
-    willReturn[ i ] = start + i
-  }
+    for (let i = 0; i < len + 1; i++) {
+      willReturn[i] = start + i
+    }
 
-  return willReturn
+    return willReturn
+  }
 }
+
+export function rangeDescending(start) {
+  return end => {
+    if (Number.isNaN(Number(start)) || Number.isNaN(Number(end))) {
+      throw new TypeError('Both arguments to range must be numbers')
+    }
+
+    if (end >= start) {
+      return []
+    }
+
+    const len = start - end
+    const willReturn = Array(len)
+
+    for (let i = 0; i < len + 1; i++) {
+      willReturn[i] = start - i
+    }
+
+    return willReturn
+  }
 }

package/src/reject.js

@@ -1,5 +1,5 @@
 import { filter } from './filter.js'
 
 export function reject(predicate) {
-  return list => filter(x => !predicate(x), list)
+  return list => filter(x => !predicate(x))(list)
 }

package/src/rejectObject.js

@@ -0,0 +1,13 @@
+export function rejectObject(predicate) {
+  return obj => {
+    const willReturn = {}
+
+    for (const prop in obj) {
+      if (!predicate(obj[prop], prop, obj)) {
+        willReturn[prop] = obj[prop]
+      }
+    }
+
+    return willReturn
+  }
+}

package/src/shuffle.js

@@ -0,0 +1,13 @@
+export 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
+  }
+
+  return list
+}

package/src/sort.js

@@ -1,5 +1,5 @@
 import { cloneList } from './_internals/cloneList.js'
 
-export function sort(sortFn){
+export function sort(sortFn) {
   return list => cloneList(list).sort(sortFn)
 }

package/src/sortBy.js

@@ -1,16 +1,18 @@
 import { cloneList } from './_internals/cloneList.js'
 
-export function sortBy(sortFn){
-	return list => {
-  const clone = cloneList(list)
+export function sortBy(sortFn) {
+  return list => {
+    const clone = cloneList(list)
 
-  return clone.sort((a, b) => {
-    const aSortResult = sortFn(a)
-    const bSortResult = sortFn(b)
+    return clone.sort((a, b) => {
+      const aSortResult = sortFn(a)
+      const bSortResult = sortFn(b)
 
-    if (aSortResult === bSortResult) return 0
+      if (aSortResult === bSortResult) {
+        return 0
+      }
 
-    return aSortResult < bSortResult ? -1 : 1
-  })
-}
+      return aSortResult < bSortResult ? -1 : 1
+    })
+  }
 }

package/src/sortObject.js

@@ -0,0 +1,15 @@
+import { sort } from './sort.js'
+
+export 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
+  }
+}

package/src/sortWith.js

@@ -10,14 +10,14 @@ function sortHelper(a, b, listOfSortingFns) {
 }
 
 export 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
+  }
 }

package/src/split.js

@@ -1,3 +1,3 @@
-export function split(separator){
-	return str => str.split(separator)
+export function split(separator) {
+  return str => str.split(separator)
 }

package/src/splitEvery.js

@@ -1,16 +1,16 @@
 export 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
+  }
 }

package/src/takeLastWhile.js

@@ -1,20 +1,20 @@
 export 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()
+  }
 }

package/src/tap.js

@@ -1,7 +1,7 @@
 export function tap(fn) {
-	return x => {
-  fn(x)
+  return x => {
+    fn(x)
 
-  return x
-}
+    return x
+  }
 }

package/src/test.js

@@ -1,3 +1,3 @@
 export function test(pattern) {
-	return str => str.search(pattern) !== -1
+  return str => str.search(pattern) !== -1
 }

package/src/uniqBy.js

@@ -1,9 +1,9 @@
 import { _Set } from '../src/_internals/set.js'
 
 export 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)))
+  }
 }

package/src/uniqWith.js

@@ -14,18 +14,18 @@ function includesWith(predicate, target, list) {
 }
 
 export 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
+  }
 }

package/src/modifyPath.js

@@ -1,30 +0,0 @@
-import { createPath } from './_internals/createPath.js'
-import { path as pathModule } from './path.js'
-
-function assoc(prop, newValue) {
-  return obj => Object.assign({}, obj, { [prop]: newValue })
-}
-
-function modifyPathFn(pathInput, fn, obj) {
-    const path = createPath(pathInput)
-    if (path.length === 1) {
-      return {
-        ...obj,
-        [path[0]]: fn(obj[path[0]]),
-      }
-    }
-    if (pathModule(path)(obj) === undefined) {
-      return obj
-    }
-
-    const val = modifyPathFn(Array.prototype.slice.call(path, 1), fn, obj[path[0]])
-    if (val === obj[path[0]]) {
-      return obj
-    }
-
-    return assoc(path[0], val)(obj)
-}
-
-export function modifyPath(pathInput, fn) {
-  return obj => modifyPathFn(pathInput, fn, obj)
-}