rambda 8.2.0 → 8.4.0

package/src/assocPath.js

@@ -1,19 +1,15 @@
 import { cloneList } from './_internals/cloneList.js'
+import { createPath } from './_internals/createPath.js'
 import { isArray } from './_internals/isArray.js'
-import { isInteger } from './_internals/isInteger.js'
-import { assoc } from './assoc.js'
+import { isIndexInteger } from './_internals/isInteger.js'
+import { assocFn } from './assoc.js'
 import { curry } from './curry.js'
 
-function assocPathFn(
+export function assocPathFn(
   path, newValue, input
 ){
-  const pathArrValue =
-    typeof path === 'string' ?
-      path.split('.').map(x => isInteger(Number(x)) ? Number(x) : x) :
-      path
-  if (pathArrValue.length === 0){
-    return newValue
-  }
+  const pathArrValue = createPath(path)
+  if (pathArrValue.length === 0) return newValue
 
   const index = pathArrValue[ 0 ]
   if (pathArrValue.length > 1){
@@ -23,7 +19,7 @@ function assocPathFn(
       !input.hasOwnProperty(index)
 
     const nextInput = condition ?
-      isInteger(pathArrValue[ 1 ]) ?
+      isIndexInteger(pathArrValue[ 1 ]) ?
         [] :
         {} :
       input[ index ]
@@ -35,14 +31,14 @@ function assocPathFn(
     )
   }
 
-  if (isInteger(index) && isArray(input)){
+  if (isIndexInteger(index) && isArray(input)){
     const arr = cloneList(input)
     arr[ index ] = newValue
 
     return arr
   }
 
-  return assoc(
+  return assocFn(
     index, newValue, input
   )
 }

package/src/binary.js

@@ -0,0 +1,5 @@
+export function binary(fn){
+  if (fn.length <= 2) return fn
+
+  return (a, b) => fn(a, b)
+}

package/src/call.js

@@ -0,0 +1 @@
+export const call = (fn, ...inputs) => fn(...inputs)

package/src/collectBy.js

@@ -0,0 +1,27 @@
+import { reduce } from './reduce.js'
+
+export function collectBy(fn, list){
+  if (arguments.length === 1){
+    return _list => collectBy(fn, _list)
+  }
+
+  const group = reduce(
+    (o, x) => {
+      const tag = fn(x)
+      if (o[ tag ] === undefined){
+        o[ tag ] = []
+      }
+      o[ tag ].push(x)
+
+      return o
+    },
+    {},
+    list
+  )
+  const newList = []
+  for (const tag in group){
+    newList.push(group[ tag ])
+  }
+
+  return newList
+}

package/src/comparator.js

@@ -0,0 +1,5 @@
+export function comparator(fn){
+  return function (a, b){
+    return fn(a, b) ? -1 : fn(b, a) ? 1 : 0
+  }
+}

package/src/composeWith.js

@@ -0,0 +1,33 @@
+import { _arity } from './_internals/_arity.js'
+import { head } from './head.js'
+import { identity } from './identity.js'
+import { reduce } from './reduce.js'
+import { reverse } from './reverse.js'
+import { tail } from './tail.js'
+
+export function pipeWith(xf, list){
+  if (list.length <= 0){
+    return identity
+  }
+
+  const headList = head(list)
+  const tailList = tail(list)
+
+  return _arity(headList.length, function (){
+    return reduce(
+      function (result, f){
+        return xf.call(
+          this, f, result
+        )
+      },
+      headList.apply(this, arguments),
+      tailList
+    )
+  })
+}
+
+export function composeWith(xf, list){
+  if (arguments.length === 1) return _list => composeWith(xf, _list)
+
+  return pipeWith.apply(this, [ xf, reverse(list) ])
+}

package/src/curryN.js

@@ -1,3 +1,5 @@
+import { _arity } from './_internals/_arity.js'
+
 function _curryN(
   n, cache, fn
 ){
@@ -25,71 +27,6 @@ function _curryN(
   }
 }
 
-function _arity(n, fn){
-  switch (n){
-  case 0:
-    return function (){
-      return fn.apply(this, arguments)
-    }
-  case 1:
-    return function (_1){
-      return fn.apply(this, arguments)
-    }
-  case 2:
-    return function (_1, _2){
-      return fn.apply(this, arguments)
-    }
-  case 3:
-    return function (
-      _1, _2, _3
-    ){
-      return fn.apply(this, arguments)
-    }
-  case 4:
-    return function (
-      _1, _2, _3, _4
-    ){
-      return fn.apply(this, arguments)
-    }
-  case 5:
-    return function (
-      _1, _2, _3, _4, _5
-    ){
-      return fn.apply(this, arguments)
-    }
-  case 6:
-    return function (
-      _1, _2, _3, _4, _5, _6
-    ){
-      return fn.apply(this, arguments)
-    }
-  case 7:
-    return function (
-      _1, _2, _3, _4, _5, _6, _7
-    ){
-      return fn.apply(this, arguments)
-    }
-  case 8:
-    return function (
-      _1, _2, _3, _4, _5, _6, _7, _8
-    ){
-      return fn.apply(this, arguments)
-    }
-  case 9:
-    return function (
-      _1, _2, _3, _4, _5, _6, _7, _8, _9
-    ){
-      return fn.apply(this, arguments)
-    }
-  default:
-    return function (
-      _1, _2, _3, _4, _5, _6, _7, _8, _9, _10
-    ){
-      return fn.apply(this, arguments)
-    }
-  }
-}
-
 export function curryN(n, fn){
   if (arguments.length === 1) return _fn => curryN(n, _fn)
 

package/src/dissocPath.js

@@ -0,0 +1,47 @@
+import { createPath } from '../src/_internals/createPath.js'
+import { isArray } from './_internals/isArray.js'
+import { isIndexInteger } from './_internals/isInteger.js'
+import { omit } from './omit.js'
+import { path } from './path.js'
+import { removeIndex } from './removeIndex.js'
+import { update } from './update.js'
+
+export function dissocPath(pathInput, input){
+  if (arguments.length === 1) return _obj => dissocPath(pathInput, _obj)
+
+  const pathArrValue = createPath(pathInput)
+  // this {...input} spread could be done to satisfy ramda specs, but this is done on so many places
+  // TODO: add warning that Rambda simply returns input if path is empty
+  if (pathArrValue.length === 0) return input
+
+  const pathResult = path(pathArrValue, input)
+  if (pathResult === undefined) return input
+
+  const index = pathArrValue[ 0 ]
+  const condition =
+    typeof input !== 'object' ||
+    input === null ||
+    !input.hasOwnProperty(index)
+  if (pathArrValue.length > 1){
+    const nextInput = condition ?
+      isIndexInteger(pathArrValue[ 1 ]) ?
+        [] :
+        {} :
+      input[ index ]
+    const nextPathInput = Array.prototype.slice.call(pathArrValue, 1)
+    const intermediateResult = dissocPath(
+      nextPathInput, nextInput, input
+    )
+    if (isArray(input)) return update(
+      index, intermediateResult, input
+    )
+
+    return {
+      ...input,
+      [ index ] : intermediateResult,
+    }
+  }
+  if (isArray(input)) return removeIndex(index, input)
+
+  return omit([ index ], input)
+}

package/src/equals.js

@@ -2,43 +2,39 @@ import { isArray } from './_internals/isArray.js'
 import { type } from './type.js'
 
 export function _lastIndexOf(valueToFind, list){
-  if (!isArray(list)){
+  if (!isArray(list))
     throw new Error(`Cannot read property 'indexOf' of ${ list }`)
-  }
+
   const typeOfValue = type(valueToFind)
-  if (![ 'Object', 'Array', 'NaN', '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 (equals(list[ index ], valueToFind))
       foundIndex = index
-    }
-  }
 
   return foundIndex
 }
 
 export function _indexOf(valueToFind, list){
-  if (!isArray(list)){
+  if (!isArray(list))
     throw new Error(`Cannot read property 'indexOf' of ${ list }`)
-  }
+
   const typeOfValue = type(valueToFind)
-  if (![ 'Object', 'Array', 'NaN', '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 (equals(list[ index ], valueToFind))
       foundIndex = index
-    }
-  }
 
   return foundIndex
 }
@@ -46,17 +42,16 @@ export function _indexOf(valueToFind, list){
 function _arrayFromIterator(iter){
   const list = []
   let next
-  while (!(next = iter.next()).done){
+  while (!(next = iter.next()).done)
     list.push(next.value)
-  }
 
   return list
 }
 
-function _equalsSets(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())
 
@@ -65,11 +60,11 @@ function _equalsSets(a, b){
   return filtered.length === 0
 }
 
-function parseError(maybeError){
-  const typeofError = maybeError.__proto__.toString()
-  if (![ 'Error', 'TypeError' ].includes(typeofError)) return []
+function compareErrors(a, b){
+  if (a.message !== b.message) return false
+  if (a.toString !== b.toString) return false
 
-  return [ typeofError, maybeError.message ]
+  return a.toString() === b.toString()
 }
 
 function parseDate(maybeDate){
@@ -90,40 +85,36 @@ export function equals(a, b){
   const aType = type(a)
 
   if (aType !== type(b)) return false
-  if (aType === 'Function'){
+  if (aType === 'Function')
     return a.name === undefined ? false : a.name === b.name
-  }
 
-  if ([ 'NaN', 'Undefined', 'Null' ].includes(aType)) return true
+  if ([ 'NaN', 'Null', 'Undefined' ].includes(aType)) return true
 
-  if (aType === 'Number'){
+  if ([ 'BigInt', 'Number' ].includes(aType)){
     if (Object.is(-0, a) !== Object.is(-0, b)) return false
 
     return a.toString() === b.toString()
   }
 
-  if ([ 'String', 'Boolean' ].includes(aType)){
+  if ([ 'Boolean', 'String' ].includes(aType))
     return a.toString() === b.toString()
-  }
 
   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 ])
-        ){
+        )
           loopArrayFlag = false
-        }
-      }
+
     })
 
     return loopArrayFlag
@@ -132,34 +123,31 @@ export function equals(a, b){
   const aRegex = parseRegex(a)
   const bRegex = parseRegex(b)
 
-  if (aRegex[ 0 ]){
+  if (aRegex[ 0 ])
     return bRegex[ 0 ] ? aRegex[ 1 ] === bRegex[ 1 ] : false
-  } else if (bRegex[ 0 ]) return false
+  else if (bRegex[ 0 ]) return false
 
   const aDate = parseDate(a)
   const bDate = parseDate(b)
 
-  if (aDate[ 0 ]){
+  if (aDate[ 0 ])
     return bDate[ 0 ] ? aDate[ 1 ] === bDate[ 1 ] : false
-  } else if (bDate[ 0 ]) return false
+  else if (bDate[ 0 ]) return false
 
-  const aError = parseError(a)
-  const bError = parseError(b)
+  if (a instanceof Error){
+    if (!(b instanceof Error)) return false
 
-  if (aError[ 0 ]){
-    return bError[ 0 ] ?
-      aError[ 0 ] === bError[ 0 ] && aError[ 1 ] === bError[ 1 ] :
-      false
-  }
-  if (aType === 'Set'){
-    return _equalsSets(a, b)
+    return compareErrors(a, b)
   }
+
+  if (aType === 'Set')
+    return _compareSets(a, b)
+
   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 => {
@@ -167,9 +155,9 @@ export function equals(a, b){
         const aValue = a[ aKeyInstance ]
         const bValue = b[ aKeyInstance ]
 
-        if (aValue !== bValue && !equals(aValue, bValue)){
+        if (aValue !== bValue && !equals(aValue, bValue))
           loopObjectFlag = false
-        }
+
       }
     })
 

package/src/omit.js

@@ -1,20 +1,18 @@
 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)
 
-  if (obj === null || obj === undefined){
+  if (obj === null || obj === undefined)
     return undefined
-  }
 
   const propsToOmitValue = createPath(propsToOmit, ',')
   const willReturn = {}
 
-  for (const key in obj){
-    if (!propsToOmitValue.includes(key)){
+  for (const key in obj)
+    if (!includes(key, propsToOmitValue))
       willReturn[ key ] = obj[ key ]
-    }
-  }
 
   return willReturn
 }

package/src/partial.js

@@ -1,11 +1,17 @@
+import { isArray } from './_internals/isArray.js'
+
 export function partial(fn, ...args){
   const len = fn.length
 
+  // If a single array argument is given, those are the args (a la Ramda).
+  // Otherwise, the variadic arguments are the args.
+  const argList = args.length === 1 && isArray(args[0]) ? args[0] : args
+
   return (...rest) => {
-    if (args.length + rest.length >= len){
-      return fn(...args, ...rest)
+    if (argList.length + rest.length >= len){
+      return fn(...argList, ...rest)
     }
 
-    return partial(fn, ...[ ...args, ...rest ])
+    return partial(fn, ...[ ...argList, ...rest ])
   }
 }

package/src/pipe.js

@@ -1,72 +1,6 @@
+import { _arity } from './_internals/_arity.js'
 import { reduceFn } from './reduce.js'
 
-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')
-  }
-}
-
 export function _pipe(f, g){
   return function (){
     return g.call(this, f.apply(this, arguments))

package/src/removeIndex.js

@@ -0,0 +1,7 @@
+export function removeIndex(index, list){
+  if (arguments.length === 1) return _list => removeIndex(index, _list)
+  if (index <= 0) return list.slice(1)
+  if (index >= list.length - 1) return list.slice(0, list.length - 1)
+
+  return [ ...list.slice(0, index), ...list.slice(index + 1) ]
+}