rambda 9.4.2 → 10.0.0-beta.1

package/src/mapObjectAsync.js

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

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, input){
-  if (arguments.length === 1) return _input => match(pattern, _input)
+export function match(pattern) {
+  return input => {
+    const willReturn = input.match(pattern)
 
-  const willReturn = input.match(pattern)
-
-  return willReturn === null ? [] : willReturn
+    return willReturn === null ? [] : willReturn
+  }
 }

package/src/maxBy.js

@@ -1,9 +1,3 @@
-import { curry } from './curry.js'
-
-export function maxByFn(
-  compareFn, x, y
-){
-  return compareFn(y) > compareFn(x) ? y : x
+export function maxBy(compareFn, x) {
+  return y => (compareFn(y) > compareFn(x) ? y : x)
 }
-
-export const maxBy = curry(maxByFn)

package/src/merge.js

@@ -1 +1,4 @@
-export { mergeRight as merge } from './mergeRight.js'
+export function merge(target) {
+  return objectWithNewProps =>
+    Object.assign({}, target || {}, objectWithNewProps || {})
+}

package/src/mergeTypes.js

@@ -0,0 +1,3 @@
+export function mergeTypes(x) {
+  return x
+}

package/src/minBy.js

@@ -1,9 +1,3 @@
-import { curry } from './curry.js'
-
-export function minByFn(
-  compareFn, x, y
-){
-  return compareFn(y) < compareFn(x) ? y : x
+export function minBy(compareFn, x) {
+  return y => (compareFn(y) < compareFn(x) ? y : x)
 }
-
-export const minBy = curry(minByFn)

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/none.js

@@ -1,9 +1,11 @@
-export function none(predicate, list){
-  if (arguments.length === 1) return _list => none(predicate, _list)
+export function none(predicate) {
+  return list => {
+    for (let i = 0; i < list.length; i++) {
+      if (predicate(list[i])) {
+        return false
+      }
+    }
 
-  for (let i = 0; i < list.length; i++){
-    if (predicate(list[ i ])) return false
+    return true
   }
-
-  return true
 }

package/src/objOf.js

@@ -1,7 +1,3 @@
-export function objOf(key, value){
-  if (arguments.length === 1){
-    return _value => objOf(key, _value)
-  }
-
-  return { [ key ] : value }
+export function objOf(key) {
+  return value => ({ [key]: value })
 }

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/omit.js

@@ -1,18 +1,33 @@
 import { createPath } from './_internals/createPath.js'
-import { includes } from './_internals/includes.js'
 
-export function omit(propsToOmit, obj){
-  if (arguments.length === 1) return _obj => omit(propsToOmit, _obj)
+export function _includes(x, list) {
+  let index = -1
+  const { length } = list
 
-  if (obj === null || obj === undefined)
-    return undefined
+  while (++index < length) {
+    if (String(list[index]) === String(x)) {
+      return true
+    }
+  }
 
-  const propsToOmitValue = createPath(propsToOmit, ',')
-  const willReturn = {}
+  return false
+}
+
+export function omit(propsToOmit) {
+  return obj => {
+    if (!obj) {
+      return undefined
+    }
+
+    const propsToOmitValue = createPath(propsToOmit, ',')
+    const willReturn = {}
 
-  for (const key in obj)
-    if (!includes(key, propsToOmitValue))
-      willReturn[ key ] = obj[ key ]
+    for (const key in obj) {
+      if (!_includes(key, propsToOmitValue)) {
+        willReturn[key] = obj[key]
+      }
+    }
 
-  return willReturn
+    return willReturn
+  }
 }

package/src/partition.js

@@ -1,44 +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, iterable){
-  if (arguments.length === 1){
-    return listHolder => partition(predicate, listHolder)
+export 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]
   }
-  if (!isArray(iterable)) return partitionObject(predicate, iterable)
-
-  return partitionArray(predicate, iterable)
 }

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/path.js

@@ -1,30 +1,29 @@
 import { createPath } from './_internals/createPath.js'
 
-export function pathFn(pathInput, obj){
+export function path(pathInput, obj) {
+  if (arguments.length === 1) {
+    return _obj => path(pathInput, _obj)
+  }
+
+  if (!obj) {
+    return undefined
+  }
   let willReturn = obj
   let counter = 0
 
   const pathArrValue = createPath(pathInput)
 
-  while (counter < pathArrValue.length){
-    if (willReturn === null || willReturn === undefined){
+  while (counter < pathArrValue.length) {
+    if (willReturn === null || willReturn === undefined) {
+      return undefined
+    }
+    if (willReturn[pathArrValue[counter]] === null) {
       return undefined
     }
-    if (willReturn[ pathArrValue[ counter ] ] === null) return undefined
 
-    willReturn = willReturn[ pathArrValue[ counter ] ]
+    willReturn = willReturn[pathArrValue[counter]]
     counter++
   }
 
   return willReturn
 }
-
-export function path(pathInput, obj){
-  if (arguments.length === 1) return _obj => path(pathInput, _obj)
-
-  if (obj === null || obj === undefined){
-    return undefined
-  }
-
-  return pathFn(pathInput, obj)
-}

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/pick.js

@@ -1,21 +1,21 @@
 import { createPath } from './_internals/createPath.js'
 
-export function pick(propsToPick, input){
-  if (arguments.length === 1) return _input => pick(propsToPick, _input)
-
-  if (input === null || input === undefined){
-    return undefined
-  }
-  const keys = createPath(propsToPick, ',')
-  const willReturn = {}
-  let counter = 0
+export function pick(propsToPick) {
+  return input => {
+    if (!input === null) {
+      return undefined
+    }
+    const keys = createPath(propsToPick, ',')
+    const willReturn = {}
+    let counter = 0
 
-  while (counter < keys.length){
-    if (keys[ counter ] in input){
-      willReturn[ keys[ counter ] ] = input[ keys[ counter ] ]
+    while (counter < keys.length) {
+      if (keys[counter] in input) {
+        willReturn[keys[counter]] = input[keys[counter]]
+      }
+      counter++
     }
-    counter++
-  }
 
-  return willReturn
+    return willReturn
+  }
 }

package/src/pipe.js

@@ -1,23 +1,80 @@
-import { _arity } from './_internals/_arity.js'
-import { reduceFn } from './reduce.js'
+import { reduce } from './reduce.js'
 
-export function _pipe(f, g){
-  return function (){
+export 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 _pipe(f, g) {
+  return function () {
     return g.call(this, f.apply(this, arguments))
   }
 }
 
-export function pipe(){
-  if (arguments.length === 0){
+function pipeFn() {
+  if (arguments.length === 0) {
     throw new Error('pipe requires at least one argument')
   }
 
-  return _arity(arguments[ 0 ].length,
-    reduceFn(
+  return _arity(
+    arguments[0].length,
+    reduce(
       _pipe,
-      arguments[ 0 ],
-      Array.prototype.slice.call(
-        arguments, 1, Infinity
-      )
-    ))
+      arguments[0],
+    )(Array.prototype.slice.call(arguments, 1, Number.POSITIVE_INFINITY)),
+  )
+}
+
+export function pipe(...inputs) {
+  const [input, ...fnList] = inputs
+
+  return pipeFn(...fnList)(input)
 }

package/src/pipeAsync.js

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

package/src/pluck.js

@@ -1,15 +1,13 @@
-import { map } from './map.js'
-
-export function pluck(property, list){
-  if (arguments.length === 1) return _list => pluck(property, _list)
-
-  const willReturn = []
-
-  map(x => {
-    if (x[ property ] !== undefined){
-      willReturn.push(x[ property ])
-    }
-  }, list)
-
-  return willReturn
+export function pluck(property) {
+  return list => {
+    const willReturn = []
+
+    list.forEach(x => {
+      if (x[property] !== undefined) {
+        willReturn.push(x[property])
+      }
+    })
+
+    return willReturn
+  }
 }

package/src/prepend.js

@@ -1,7 +1,3 @@
-export function prepend(x, input){
-  if (arguments.length === 1) return _input => prepend(x, _input)
-
-  if (typeof input === 'string') return [ x ].concat(input.split(''))
-
-  return [ x ].concat(input)
+export function prepend(x) {
+  return list => [x].concat(list)
 }

package/src/prop.js

@@ -1,11 +1,3 @@
-export function propFn(searchProperty, obj){
-  if (!obj) return undefined
-
-  return obj[ searchProperty ]
-}
-
-export function prop(searchProperty, obj){
-  if (arguments.length === 1) return _obj => prop(searchProperty, _obj)
-
-  return propFn(searchProperty, obj)
+export function prop(searchProperty) {
+  return obj => (obj ? obj[searchProperty] : undefined)
 }

package/src/propEq.js

@@ -1,13 +1,11 @@
-import { curry } from './curry.js'
-import { equals } from './equals.js'
-import { prop } from './prop.js'
+import { equalsFn } from './equals.js'
 
-function propEqFn(
-  valueToMatch, propToFind, obj
-){
-  if (!obj) return false
+export function propEq(valueToMatch, propToFind) {
+  return obj => {
+    if (!obj) {
+      return false
+    }
 
-  return equals(valueToMatch, prop(propToFind, obj))
+    return equalsFn(valueToMatch, obj[propToFind])
+  }
 }
-
-export const propEq = curry(propEqFn)

package/src/propOr.js

@@ -1,12 +1,11 @@
-import { curry } from './curry.js'
 import { defaultTo } from './defaultTo.js'
 
-function propOrFn(
-  defaultValue, property, obj
-){
-  if (!obj) return defaultValue
+export function propOr(defaultValue, property) {
+  return obj => {
+    if (!obj) {
+      return defaultValue
+    }
 
-  return defaultTo(defaultValue, obj[ property ])
+    return defaultTo(defaultValue, obj[property])
+  }
 }
-
-export const propOr = curry(propOrFn)

package/src/propSatisfies.js

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

package/src/range.js

@@ -1,18 +1,41 @@
-export function range(start, end){
-  if (arguments.length === 1) return _end => range(start, _end)
+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 (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 + 1; i++) {
+      willReturn[i] = start + i
+    }
 
-  for (let i = 0; i < len; i++){
-    willReturn[ i ] = start + i
+    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 []
+    }
 
-  return willReturn
+    const len = start - end
+    const willReturn = Array(len)
+
+    for (let i = 0; i < len + 1; i++) {
+      willReturn[i] = start - i
+    }
+
+    return willReturn
+  }
 }