rambda 7.0.2 → 7.1.1

package/src/applySpec.js

@@ -1,71 +1,93 @@
-import {_isArray} from './_internals/_isArray'
+import { _isArray } from './_internals/_isArray.js'
 
 // recursively traverse the given spec object to find the highest arity function
-function __findHighestArity(spec, max = 0) {
-  for (const key in spec) {
+export function __findHighestArity(spec, max = 0){
+  for (const key in spec){
     if (spec.hasOwnProperty(key) === false || key === 'constructor') continue
 
-    if (typeof spec[key] === 'object') {
-      max = Math.max(max, __findHighestArity(spec[key]))
+    if (typeof spec[ key ] === 'object'){
+      max = Math.max(max, __findHighestArity(spec[ key ]))
     }
 
-    if (typeof spec[key] === 'function') {
-      max = Math.max(max, spec[key].length)
+    if (typeof spec[ key ] === 'function'){
+      max = Math.max(max, spec[ key ].length)
     }
   }
 
   return max
 }
 
-function __filterUndefined() {
+function __filterUndefined(){
   const defined = []
   let i = 0
   const l = arguments.length
-  while (i < l) {
-    if (typeof arguments[i] === 'undefined') break
-    defined[i] = arguments[i]
+  while (i < l){
+    if (typeof arguments[ i ] === 'undefined') break
+    defined[ i ] = arguments[ i ]
     i++
   }
 
   return defined
 }
 
-function __applySpecWithArity(spec, arity, cache) {
+function __applySpecWithArity(
+  spec, arity, cache
+){
   const remaining = arity - cache.length
 
   if (remaining === 1)
     return x =>
-      __applySpecWithArity(spec, arity, __filterUndefined(...cache, x))
+      __applySpecWithArity(
+        spec, arity, __filterUndefined(...cache, x)
+      )
   if (remaining === 2)
     return (x, y) =>
-      __applySpecWithArity(spec, arity, __filterUndefined(...cache, x, y))
+      __applySpecWithArity(
+        spec, arity, __filterUndefined(
+          ...cache, x, y
+        )
+      )
   if (remaining === 3)
-    return (x, y, z) =>
-      __applySpecWithArity(spec, arity, __filterUndefined(...cache, x, y, z))
+    return (
+      x, y, z
+    ) =>
+      __applySpecWithArity(
+        spec, arity, __filterUndefined(
+          ...cache, x, y, z
+        )
+      )
   if (remaining === 4)
-    return (x, y, z, a) =>
+    return (
+      x, y, z, a
+    ) =>
       __applySpecWithArity(
         spec,
         arity,
-        __filterUndefined(...cache, x, y, z, a)
+        __filterUndefined(
+          ...cache, x, y, z, a
+        )
       )
   if (remaining > 4)
     return (...args) =>
-      __applySpecWithArity(spec, arity, __filterUndefined(...cache, ...args))
+      __applySpecWithArity(
+        spec, arity, __filterUndefined(...cache, ...args)
+      )
 
   // handle spec as Array
-  if (_isArray(spec)) {
+  if (_isArray(spec)){
     const ret = []
     let i = 0
     const l = spec.length
-    for (; i < l; i++) {
+    for (; i < l; i++){
       // handle recursive spec inside array
-      if (typeof spec[i] === 'object' || _isArray(spec[i])) {
-        ret[i] = __applySpecWithArity(spec[i], arity, cache)
+      if (typeof spec[ i ] === 'object' || _isArray(spec[ i ])){
+        ret[ i ] = __applySpecWithArity(
+          spec[ i ], arity, cache
+        )
       }
       // apply spec to the key
-      if (typeof spec[i] === 'function') {
-        ret[i] = spec[i](...cache)
+      if (typeof spec[ i ] === 'function'){
+        ret[ i ] = spec[ i ](...cache)
       }
     }
 
@@ -75,32 +97,36 @@ function __applySpecWithArity(spec, arity, cache) {
   // handle spec as Object
   const ret = {}
   // apply callbacks to each property in the spec object
-  for (const key in spec) {
+  for (const key in spec){
     if (spec.hasOwnProperty(key) === false || key === 'constructor') continue
 
     // apply the spec recursively
-    if (typeof spec[key] === 'object') {
-      ret[key] = __applySpecWithArity(spec[key], arity, cache)
+    if (typeof spec[ key ] === 'object'){
+      ret[ key ] = __applySpecWithArity(
+        spec[ key ], arity, cache
+      )
       continue
     }
 
     // apply spec to the key
-    if (typeof spec[key] === 'function') {
-      ret[key] = spec[key](...cache)
+    if (typeof spec[ key ] === 'function'){
+      ret[ key ] = spec[ key ](...cache)
     }
   }
 
   return ret
 }
 
-export function applySpec(spec, ...args) {
+export function applySpec(spec, ...args){
   // get the highest arity spec function, cache the result and pass to __applySpecWithArity
   const arity = __findHighestArity(spec)
 
-  if (arity === 0) {
+  if (arity === 0){
     return () => ({})
   }
-  const toReturn = __applySpecWithArity(spec, arity, args)
+  const toReturn = __applySpecWithArity(
+    spec, arity, args
+  )
 
   return toReturn
 }

package/src/assoc.js

@@ -1,7 +1,11 @@
-import {curry} from './curry'
+import { curry } from './curry.js'
 
-function assocFn(prop, newValue, obj) {
-  return Object.assign({}, obj, {[prop]: newValue})
+function assocFn(
+  prop, newValue, obj
+){
+  return Object.assign(
+    {}, obj, { [ prop ] : newValue }
+  )
 }
 
 export const assoc = curry(assocFn)

package/src/assocPath.js

@@ -1,30 +1,32 @@
-import {_isArray} from './_internals/_isArray'
-import {_isInteger} from './_internals/_isInteger'
-import {assoc} from './assoc'
-import {curry} from './curry'
-import {cloneList} from './_internals/cloneList'
-
-function assocPathFn(path, newValue, input) {
+import { _isArray } from './_internals/_isArray.js'
+import { _isInteger } from './_internals/_isInteger.js'
+import { cloneList } from './_internals/cloneList.js'
+import { assoc } from './assoc.js'
+import { curry } from './curry.js'
+
+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) {
+    typeof path === 'string' ?
+      path.split('.').map(x => _isInteger(Number(x)) ? Number(x) : x) :
+      path
+  if (pathArrValue.length === 0){
     return newValue
   }
 
-  const index = pathArrValue[0]
-  if (pathArrValue.length > 1) {
+  const index = pathArrValue[ 0 ]
+  if (pathArrValue.length > 1){
     const condition =
       typeof input !== 'object' ||
       input === null ||
       !input.hasOwnProperty(index)
 
-    const nextinput = condition
-      ? _isInteger(pathArrValue[1])
-        ? []
-        : {}
-      : input[index]
+    const nextinput = condition ?
+      _isInteger(pathArrValue[ 1 ]) ?
+        [] :
+        {} :
+      input[ index ]
 
     newValue = assocPathFn(
       Array.prototype.slice.call(pathArrValue, 1),
@@ -33,14 +35,16 @@ function assocPathFn(path, newValue, input) {
     )
   }
 
-  if (_isInteger(index) && _isArray(input)) {
+  if (_isInteger(index) && _isArray(input)){
     const arr = cloneList(input)
-    arr[index] = newValue
+    arr[ index ] = newValue
 
     return arr
   }
 
-  return assoc(index, newValue, input)
+  return assoc(
+    index, newValue, input
+  )
 }
 
 export const assocPath = curry(assocPathFn)

package/src/bind.js

@@ -1,7 +1,7 @@
-import {curryN} from './curryN'
+import { curryN } from './curryN.js'
 
-export function bind(fn, thisObj) {
-  if (arguments.length === 1) {
+export function bind(fn, thisObj){
+  if (arguments.length === 1){
     return _thisObj => bind(fn, _thisObj)
   }
 

package/src/both.js

@@ -1,4 +1,4 @@
-export function both(f, g) {
+export function both(f, g){
   if (arguments.length === 1) return _g => both(f, _g)
 
   return (...input) => f(...input) && g(...input)

package/src/chain.js

@@ -1,5 +1,5 @@
-export function chain(fn, list) {
-  if (arguments.length === 1) {
+export function chain(fn, list){
+  if (arguments.length === 1){
     return _list => chain(fn, _list)
   }
 

package/src/clamp.js

@@ -1,10 +1,10 @@
-import {curry} from './curry'
+import { curry } from './curry.js'
 
-function clampFn(min, max, input) {
-  if (min > max) {
-    throw new Error(
-      'min must not be greater than max in clamp(min, max, value)'
-    )
+function clampFn(
+  min, max, input
+){
+  if (min > max){
+    throw new Error('min must not be greater than max in clamp(min, max, value)')
   }
   if (input >= min && input <= max) return input
 

package/src/clone.js

@@ -1,17 +1,17 @@
-import {_isArray} from './_internals/_isArray'
+import { _isArray } from './_internals/_isArray.js'
 
-export function clone(input) {
+export function clone(input){
   const out = _isArray(input) ? Array(input.length) : {}
   if (input && input.getTime) return new Date(input.getTime())
 
-  for (const key in input) {
-    const v = input[key]
-    out[key] =
-      typeof v === 'object' && v !== null
-        ? v.getTime
-          ? new Date(v.getTime())
-          : clone(v)
-        : v
+  for (const key in input){
+    const v = input[ key ]
+    out[ key ] =
+      typeof v === 'object' && v !== null ?
+        v.getTime ?
+          new Date(v.getTime()) :
+          clone(v) :
+        v
   }
 
   return out

package/src/complement.js

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

package/src/compose.js

@@ -1,18 +1,9 @@
-export function compose(...fns) {
-  if (fns.length === 0) {
+import { pipe } from './pipe.js'
+
+export function compose(){
+  if (arguments.length === 0){
     throw new Error('compose requires at least one argument')
   }
 
-  return function (...args) {
-    const list = fns.slice()
-    if (list.length > 0) {
-      const fn = list.pop()
-      let result = fn.apply(this, args)
-      while (list.length > 0) {
-        result = list.pop()(result)
-      }
-
-      return result
-    }
-  }
+  return pipe.apply(this, Array.prototype.slice.call(arguments, 0).reverse())
 }

package/src/concat.js

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

package/src/cond.js

@@ -1,9 +1,9 @@
-export function cond(conditions) {
+export function cond(conditions){
   return input => {
     let done = false
     let toReturn
-    conditions.forEach(([predicate, resultClosure]) => {
-      if (!done && predicate(input)) {
+    conditions.forEach(([ predicate, resultClosure ]) => {
+      if (!done && predicate(input)){
         done = true
         toReturn = resultClosure(input)
       }

package/src/converge.js

@@ -1,18 +1,18 @@
-import {curryN} from './curryN'
-import {map} from './map'
-import {max} from './max'
-import {reduce} from './reduce'
+import { curryN } from './curryN.js'
+import { map } from './map.js'
+import { max } from './max.js'
+import { reduce } from './reduce.js'
 
-export function converge(fn, transformers) {
+export function converge(fn, transformers){
   if (arguments.length === 1)
     return _transformers => converge(fn, _transformers)
 
-  const highestArity = reduce((a, b) => max(a, b.length), 0, transformers)
+  const highestArity = reduce(
+    (a, b) => max(a, b.length), 0, transformers
+  )
 
-  return curryN(highestArity, function () {
-    return fn.apply(
-      this,
-      map(g => g.apply(this, arguments), transformers)
-    )
+  return curryN(highestArity, function (){
+    return fn.apply(this,
+      map(g => g.apply(this, arguments), transformers))
   })
 }

package/src/count.js

@@ -0,0 +1,10 @@
+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
+
+  return list.filter(x => predicate(x)).length
+}

package/src/countBy.js

@@ -0,0 +1,17 @@
+export function countBy(fn, list){
+  if (arguments.length === 1){
+    return _list => countBy(fn, _list)
+  }
+  const willReturn = {}
+
+  list.forEach(item => {
+    const key = fn(item)
+    if (!willReturn[ key ]){
+      willReturn[ key ] = 1
+    } else {
+      willReturn[ key ]++
+    }
+  })
+
+  return willReturn
+}

package/src/curry.js

@@ -1,6 +1,6 @@
-export function curry(fn, args = []) {
+export function curry(fn, args = []){
   return (..._args) =>
-    (rest => (rest.length >= fn.length ? fn(...rest) : curry(fn, rest)))([
+    (rest => rest.length >= fn.length ? fn(...rest) : curry(fn, rest))([
       ...args,
       ..._args,
     ])

package/src/curryN.js

@@ -1,83 +1,103 @@
-function _curryN(n, cache, fn) {
-  return function () {
+function _curryN(
+  n, cache, fn
+){
+  return function (){
     let ci = 0
     let ai = 0
     const cl = cache.length
     const al = arguments.length
     const args = new Array(cl + al)
-    while (ci < cl) {
-      args[ci] = cache[ci]
+    while (ci < cl){
+      args[ ci ] = cache[ ci ]
       ci++
     }
-    while (ai < al) {
-      args[cl + ai] = arguments[ai]
+    while (ai < al){
+      args[ cl + ai ] = arguments[ ai ]
       ai++
     }
     const remaining = n - args.length
 
-    return args.length >= n
-      ? fn.apply(this, args)
-      : _arity(remaining, _curryN(n, args, fn))
+    return args.length >= n ?
+      fn.apply(this, args) :
+      _arity(remaining, _curryN(
+        n, args, fn
+      ))
   }
 }
 
-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)
-      }
+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) {
+export function curryN(n, fn){
   if (arguments.length === 1) return _fn => curryN(n, _fn)
 
-  if (n > 10) {
-    throw new Error(
-      'First argument to _arity must be a non-negative integer no greater than ten'
-    )
+  if (n > 10){
+    throw new Error('First argument to _arity must be a non-negative integer no greater than ten')
   }
 
-  return _arity(n, _curryN(n, [], fn))
+  return _arity(n, _curryN(
+    n, [], fn
+  ))
 }

package/src/defaultTo.js

@@ -1,11 +1,11 @@
-function isFalsy(input) {
+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/difference.js

@@ -1,7 +1,7 @@
-import {includes} from './includes'
-import {uniq} from './uniq'
+import { includes } from './includes.js'
+import { uniq } from './uniq.js'
 
-export function difference(a, b) {
+export function difference(a, b){
   if (arguments.length === 1) return _b => difference(a, _b)
 
   return uniq(a).filter(aInstance => !includes(aInstance, b))

package/src/dissoc.js

@@ -1,13 +1,13 @@
-export function dissoc(prop, obj) {
+export function dissoc(prop, obj){
   if (arguments.length === 1) return _obj => dissoc(prop, _obj)
 
   if (obj === null || obj === undefined) return {}
 
   const willReturn = {}
-  for (const p in obj) {
-    willReturn[p] = obj[p]
+  for (const p in obj){
+    willReturn[ p ] = obj[ p ]
   }
-  delete willReturn[prop]
+  delete willReturn[ prop ]
 
   return willReturn
 }

package/src/divide.js

@@ -1,4 +1,4 @@
-export function divide(a, b) {
+export function divide(a, b){
   if (arguments.length === 1) return _b => divide(a, _b)
 
   return a / b