rambda 9.4.2 → 10.0.0-beta.1

package/src/append.js

@@ -1,12 +1,10 @@
 import { cloneList } from './_internals/cloneList.js'
 
-export function append(x, input){
-  if (arguments.length === 1) return _input => append(x, _input)
+export function append(x) {
+  return list => {
+    const clone = cloneList(list)
+    clone.push(x)
 
-  if (typeof input === 'string') return input.split('').concat(x)
-
-  const clone = cloneList(input)
-  clone.push(x)
-
-  return clone
+    return clone
+  }
 }

package/src/ascend.js

@@ -1,23 +1,16 @@
-export function createCompareFunction(
-  a, b, winner, loser
-){
-  if (a === b) return 0
+export function createCompareFunction(a, b, winner, loser) {
+  if (a === b) {
+    return 0
+  }
 
   return a < b ? winner : loser
 }
 
-export function ascend(
-  getFunction, a, b
-){
-  if (arguments.length === 1){
-    return (_a, _b) => ascend(
-      getFunction, _a, _b
-    )
-  }
+export function ascend(getFunction) {
+	return (a, b) => {
   const aValue = getFunction(a)
   const bValue = getFunction(b)
 
-  return createCompareFunction(
-    aValue, bValue, -1, 1
-  )
+  return createCompareFunction(aValue, bValue, -1, 1)
+}
 }

package/src/checkObjectWithSpec.js

@@ -0,0 +1,16 @@
+export function checkObjectWithSpec(conditions) {
+  return input => {
+    let shouldProceed = true
+    for (const prop in conditions) {
+      if (!shouldProceed) {
+        continue
+      }
+      const result = conditions[prop](input[prop])
+      if (shouldProceed && result === false) {
+        shouldProceed = false
+      }
+    }
+
+    return shouldProceed
+  }
+}

package/src/compact.js

@@ -0,0 +1,12 @@
+import { isArray } from './_internals/isArray.js'
+import { reject } from './reject.js'
+import { rejectObject } from './rejectObject.js'
+
+const isNullOrUndefined = x => x === null || x === undefined
+
+export function compact(input){
+	if(isArray(input)){
+		return reject(isNullOrUndefined)(input)
+	}
+	return rejectObject(isNullOrUndefined)(input)
+}

package/src/complement.js

@@ -1,3 +1,3 @@
-export function complement(fn){
+export function complement(fn) {
   return (...input) => !fn(...input)
 }

package/src/concat.js

@@ -1,5 +1,3 @@
-export function concat(x, y){
-  if (arguments.length === 1) return _y => concat(x, _y)
-
-  return typeof x === 'string' ? `${ x }${ y }` : [ ...x, ...y ]
+export function concat(x) {
+  return y => (typeof x === 'string' ? `${x}${y}` : [...x, ...y])
 }

package/src/count.js

@@ -1,10 +1,11 @@
 import { isArray } from './_internals/isArray.js'
 
-export function count(predicate, list){
-  if (arguments.length === 1){
-    return _list => count(predicate, _list)
-  }
-  if (!isArray(list)) return 0
+export function count(predicate) {
+  return list => {
+    if (!isArray(list)) {
+      return 0
+    }
 
-  return list.filter(x => predicate(x)).length
+    return list.filter(x => predicate(x)).length
+  }
 }

package/src/countBy.js

@@ -1,17 +1,16 @@
-export function countBy(fn, list){
-  if (arguments.length === 1){
-    return _list => countBy(fn, _list)
-  }
-  const willReturn = {}
+export function countBy(fn) {
+  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
+  }
 }

package/src/createObjectFromKeys.js

@@ -0,0 +1,10 @@
+export function createObjectFromKeys(keys) {
+	return fn => {
+		const result = {}
+		keys.forEach((key, index) => {
+			result[key] = fn(key, index)
+		})
+
+		return result
+	}
+}

package/src/defaultTo.js

@@ -1,11 +1,9 @@
-function isFalsy(input){
-  return (
-    input === undefined || input === null || Number.isNaN(input) === true
-  )
+function isFalsy(input) {
+  return input === undefined || input === null || Number.isNaN(input) === true
 }
 
-export function defaultTo(defaultArgument, input){
-  if (arguments.length === 1){
+export function defaultTo(defaultArgument, input) {
+  if (arguments.length === 1) {
     return _input => defaultTo(defaultArgument, _input)
   }
 

package/src/descend.js

@@ -1,17 +1,10 @@
 import { createCompareFunction } from './ascend.js'
 
-export function descend(
-  getFunction, a, b
-){
-  if (arguments.length === 1){
-    return (_a, _b) => descend(
-      getFunction, _a, _b
-    )
-  }
-  const aValue = getFunction(a)
-  const bValue = getFunction(b)
+export function descend(getFunction) {
+  return (a, b) => {
+    const aValue = getFunction(a)
+    const bValue = getFunction(b)
 
-  return createCompareFunction(
-    aValue, bValue, 1, -1
-  )
+    return createCompareFunction(aValue, bValue, 1, -1)
+  }
 }

package/src/drop.js

@@ -1,5 +1,7 @@
-export function drop(howManyToDrop, listOrString){
-  if (arguments.length === 1) return _list => drop(howManyToDrop, _list)
+export function drop(howManyToDrop, listOrString) {
+  if (arguments.length === 1) {
+    return _list => drop(howManyToDrop, _list)
+  }
 
   return listOrString.slice(howManyToDrop > 0 ? howManyToDrop : 0)
 }

package/src/dropLast.js

@@ -1,9 +1,3 @@
-export function dropLast(howManyToDrop, listOrString){
-  if (arguments.length === 1){
-    return _listOrString => dropLast(howManyToDrop, _listOrString)
-  }
-
-  return howManyToDrop > 0 ?
-    listOrString.slice(0, -howManyToDrop) :
-    listOrString.slice()
+export function dropLast(numberItems) {
+  return list => (numberItems > 0 ? list.slice(0, -numberItems) : list.slice())
 }

package/src/dropLastWhile.js

@@ -1,33 +1,24 @@
-import { isArray as isArrayMethod } from './_internals/isArray.js'
-
-export function dropLastWhile(predicate, iterable){
-  if (arguments.length === 1){
-    return _iterable => dropLastWhile(predicate, _iterable)
-  }
-  if (iterable.length === 0) return iterable
-  const isArray = isArrayMethod(iterable)
+export function dropLastWhile(predicate) {
+  return list => {
+    if (list.length === 0) {
+      return list
+    }
 
-  if (typeof predicate !== 'function'){
-    throw new Error(`'predicate' is from wrong type ${ typeof predicate }`)
-  }
-  if (!isArray && typeof iterable !== 'string'){
-    throw new Error(`'iterable' is from wrong type ${ typeof iterable }`)
-  }
+    const toReturn = []
+    let counter = list.length
 
-  const toReturn = []
-  let counter = iterable.length
+    while (counter) {
+      const item = list[--counter]
+      if (!predicate(item, counter)) {
+        toReturn.push(item)
+        break
+      }
+    }
 
-  while (counter){
-    const item = iterable[ --counter ]
-    if (!predicate(item)){
-      toReturn.push(item)
-      break
+    while (counter) {
+      toReturn.push(list[--counter])
     }
-  }
 
-  while (counter){
-    toReturn.push(iterable[ --counter ])
+    return toReturn.reverse()
   }
-
-  return isArray ? toReturn.reverse() : toReturn.reverse().join('')
 }

package/src/dropWhile.js

@@ -1,28 +1,20 @@
-import { isArray as isArrayMethod } from './_internals/isArray.js'
+export function dropWhile(predicate) {
+  return iterable => {
+    const toReturn = []
+    let counter = 0
 
-export function dropWhile(predicate, iterable){
-  if (arguments.length === 1){
-    return _iterable => dropWhile(predicate, _iterable)
-  }
-  const isArray = isArrayMethod(iterable)
-  if (!isArray && typeof iterable !== 'string'){
-    throw new Error('`iterable` is neither list nor a string')
-  }
-
-  const toReturn = []
-  let counter = 0
+    while (counter < iterable.length) {
+      const item = iterable[counter++]
+      if (!predicate(item, counter)) {
+        toReturn.push(item)
+        break
+      }
+    }
 
-  while (counter < iterable.length){
-    const item = iterable[ counter++ ]
-    if (!predicate(item)){
-      toReturn.push(item)
-      break
+    while (counter < iterable.length) {
+      toReturn.push(iterable[counter++])
     }
-  }
 
-  while (counter < iterable.length){
-    toReturn.push(iterable[ counter++ ])
+    return toReturn
   }
-
-  return isArray ? toReturn : toReturn.join('')
 }

package/src/eqBy.js

@@ -1,10 +1,5 @@
-import { curry } from './curry.js'
-import { equals } from './equals.js'
+import { equalsFn } from './equals.js'
 
-export function eqByFn(
-  fn, a, b
-){
-  return equals(fn(a), fn(b))
+export function eqBy(fn, a) {
+  return b => equalsFn(fn(a), fn(b))
 }
-
-export const eqBy = curry(eqByFn)

package/src/eqProps.js

@@ -1,11 +1,5 @@
-import { curry } from './curry.js'
-import { equals } from './equals.js'
-import { prop } from './prop.js'
+import { equalsFn } from './equals.js'
 
-function eqPropsFn(
-  property, objA, objB
-){
-  return equals(prop(property, objA), prop(property, objB))
+export function eqProps(property, objA) {
+  return objB => equalsFn( objA[property], objB[property] )
 }
-
-export const eqProps = curry(eqPropsFn)

package/src/equals.js

@@ -1,56 +1,66 @@
 import { isArray } from './_internals/isArray.js'
 import { type } from './type.js'
 
-export function _lastIndexOf(valueToFind, list){
-  if (!isArray(list))
-    throw new Error(`Cannot read property 'indexOf' of ${ list }`)
+export function _lastIndexOf(valueToFind, list) {
+  if (!isArray(list)) {
+    throw new Error(`Cannot read property 'indexOf' of ${list}`)
+  }
 
   const typeOfValue = type(valueToFind)
-  if (![ 'Array', 'NaN', 'Object', 'RegExp' ].includes(typeOfValue))
+  if (!['Array', 'NaN', 'Object', '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))
+  while (--index > -1 && foundIndex === -1) {
+    if (equalsFn(list[index], valueToFind)) {
       foundIndex = index
+    }
+  }
 
   return foundIndex
 }
 
-export function _indexOf(valueToFind, list){
-  if (!isArray(list))
-    throw new Error(`Cannot read property 'indexOf' of ${ list }`)
+export function _indexOf(valueToFind, list) {
+  if (!isArray(list)) {
+    throw new Error(`Cannot read property 'indexOf' of ${list}`)
+  }
 
   const typeOfValue = type(valueToFind)
-  if (![ 'Array', 'NaN', 'Object', 'RegExp' ].includes(typeOfValue))
+  if (!['Array', 'NaN', 'Object', '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))
+  while (++index < length && foundIndex === -1) {
+    if (equalsFn(list[index], valueToFind)) {
       foundIndex = index
+    }
+  }
 
   return foundIndex
 }
 
-function _arrayFromIterator(iter){
+function _arrayFromIterator(iter) {
   const list = []
   let next
-  while (!(next = iter.next()).done)
+  while (!(next = iter.next()).done) {
     list.push(next.value)
+  }
 
   return list
 }
 
-function _compareSets(a, b){
-  if (a.size !== b.size)
+function _compareSets(a, b) {
+  if (a.size !== b.size) {
     return false
+  }
 
   const aList = _arrayFromIterator(a.values())
   const bList = _arrayFromIterator(b.values())
@@ -60,63 +70,81 @@ function _compareSets(a, b){
   return filtered.length === 0
 }
 
-function compareErrors(a, b){
-  if (a.message !== b.message) return false
-  if (a.toString !== b.toString) return false
+function compareErrors(a, b) {
+  if (a.message !== b.message) {
+    return false
+  }
+  if (a.toString !== b.toString) {
+    return false
+  }
 
   return a.toString() === b.toString()
 }
 
-function parseDate(maybeDate){
-  if (!maybeDate.toDateString) return [ false ]
+function parseDate(maybeDate) {
+  if (!maybeDate.toDateString) {
+    return [false]
+  }
 
-  return [ true, maybeDate.getTime() ]
+  return [true, maybeDate.getTime()]
 }
 
-function parseRegex(maybeRegex){
-  if (maybeRegex.constructor !== RegExp) return [ false ]
+function parseRegex(maybeRegex) {
+  if (maybeRegex.constructor !== RegExp) {
+    return [false]
+  }
 
-  return [ true, maybeRegex.toString() ]
+  return [true, maybeRegex.toString()]
 }
 
-export function equals(a, b){
-  if (arguments.length === 1) return _b => equals(a, _b)
-
-  if (Object.is(a, b)) return true
+export function equalsFn(a, b) {
+  if (Object.is(a, b)) {
+    return true
+  }
 
   const aType = type(a)
 
-  if (aType !== type(b)) return false
-  if (aType === 'Function')
+  if (aType !== type(b)) {
+    return false
+  }
+  if (aType === 'Function') {
     return a.name === undefined ? false : a.name === b.name
+  }
 
-  if ([ 'NaN', 'Null', 'Undefined' ].includes(aType)) return true
+  if (['NaN', 'Null', 'Undefined'].includes(aType)) {
+    return true
+  }
 
-  if ([ 'BigInt', 'Number' ].includes(aType)){
-    if (Object.is(-0, a) !== Object.is(-0, b)) return false
+  if (['BigInt', 'Number'].includes(aType)) {
+    if (Object.is(-0, a) !== Object.is(-0, b)) {
+      return false
+    }
 
     return a.toString() === b.toString()
   }
 
-  if ([ 'Boolean', 'String' ].includes(aType))
+  if (['Boolean', 'String'].includes(aType)) {
     return a.toString() === b.toString()
+  }
 
-  if (aType === 'Array'){
+  if (aType === 'Array') {
     const aClone = Array.from(a)
     const bClone = Array.from(b)
 
-    if (aClone.toString() !== bClone.toString())
+    if (aClone.toString() !== bClone.toString()) {
       return false
+    }
 
     let loopArrayFlag = true
     aClone.forEach((aCloneInstance, aCloneIndex) => {
-      if (loopArrayFlag)
+      if (loopArrayFlag) {
         if (
-          aCloneInstance !== bClone[ aCloneIndex ] &&
-          !equals(aCloneInstance, bClone[ aCloneIndex ])
-        )
+          aCloneInstance !== bClone[aCloneIndex] &&
+          !equalsFn(aCloneInstance, bClone[aCloneIndex])
+        ) {
           loopArrayFlag = false
-
+        }
+      }
     })
 
     return loopArrayFlag
@@ -125,41 +153,51 @@ export function equals(a, b){
   const aRegex = parseRegex(a)
   const bRegex = parseRegex(b)
 
-  if (aRegex[ 0 ])
-    return bRegex[ 0 ] ? aRegex[ 1 ] === bRegex[ 1 ] : false
-  else if (bRegex[ 0 ]) return false
+  if (aRegex[0]) {
+    return bRegex[0] ? aRegex[1] === bRegex[1] : false
+  }
+  if (bRegex[0]) {
+    return false
+  }
 
   const aDate = parseDate(a)
   const bDate = parseDate(b)
 
-  if (aDate[ 0 ])
-    return bDate[ 0 ] ? aDate[ 1 ] === bDate[ 1 ] : false
-  else if (bDate[ 0 ]) return false
+  if (aDate[0]) {
+    return bDate[0] ? aDate[1] === bDate[1] : false
+  }
+  if (bDate[0]) {
+    return false
+  }
 
-  if (a instanceof Error){
-    if (!(b instanceof Error)) return false
+  if (a instanceof Error) {
+    if (!(b instanceof Error)) {
+      return false
+    }
 
     return compareErrors(a, b)
   }
 
-  if (aType === 'Set')
+  if (aType === 'Set') {
     return _compareSets(a, b)
+  }
 
-  if (aType === 'Object'){
+  if (aType === 'Object') {
     const aKeys = Object.keys(a)
 
-    if (aKeys.length !== Object.keys(b).length)
+    if (aKeys.length !== Object.keys(b).length) {
       return false
+    }
 
     let loopObjectFlag = true
     aKeys.forEach(aKeyInstance => {
-      if (loopObjectFlag){
-        const aValue = a[ aKeyInstance ]
-        const bValue = b[ aKeyInstance ]
+      if (loopObjectFlag) {
+        const aValue = a[aKeyInstance]
+        const bValue = b[aKeyInstance]
 
-        if (aValue !== bValue && !equals(aValue, bValue))
+        if (aValue !== bValue && !equalsFn(aValue, bValue)) {
           loopObjectFlag = false
-
+        }
       }
     })
 
@@ -168,3 +206,6 @@ export function equals(a, b){
 
   return false
 }
+export function equals(a) {
+  return b => equalsFn(a, b)
+}