rambda 7.0.2 → 7.1.1

package/src/pipe.js

@@ -1,17 +1,89 @@
-export function pipe(...fns) {
-  if (fns.length === 0)
-    throw new Error('pipe requires at least one argument')
-
-  return (...args) => {
-    const list = fns.slice()
-    if (list.length > 0) {
-      const fn = list.shift()
-      let result = fn(...args)
-      while (list.length > 0) {
-        result = list.shift()(result)
-      }
+import { reduceFn } from './reduce.js'
 
-      return result
+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))
   }
 }
+
+export function pipe(){
+  if (arguments.length === 0){
+    throw new Error('pipe requires at least one argument')
+  }
+
+  return _arity(arguments[ 0 ].length,
+    reduceFn(
+      _pipe,
+      arguments[ 0 ],
+      Array.prototype.slice.call(
+        arguments, 1, Infinity
+      )
+    ))
+}

package/src/pluck.js

@@ -1,13 +1,13 @@
-import {map} from './map'
+import { map } from './map.js'
 
-export function pluck(property, list) {
+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])
+    if (x[ property ] !== undefined){
+      willReturn.push(x[ property ])
     }
   }, list)
 

package/src/prepend.js

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

package/src/product.js

@@ -1,4 +1,4 @@
-import {multiply} from './multiply'
-import {reduce} from './reduce'
+import { multiply } from './multiply.js'
+import { reduce } from './reduce.js'
 
 export const product = reduce(multiply, 1)

package/src/prop.js

@@ -1,7 +1,7 @@
-export function prop(propToFind, obj) {
+export function prop(propToFind, obj){
   if (arguments.length === 1) return _obj => prop(propToFind, _obj)
 
   if (!obj) return undefined
 
-  return obj[propToFind]
+  return obj[ propToFind ]
 }

package/src/propEq.js

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

package/src/propIs.js

@@ -1,8 +1,10 @@
-import {curry} from './curry'
-import {is} from './is'
+import { curry } from './curry.js'
+import { is } from './is.js'
 
-function propIsFn(targetPrototype, property, obj) {
-  return is(targetPrototype, obj[property])
+function propIsFn(
+  targetPrototype, property, obj
+){
+  return is(targetPrototype, obj[ property ])
 }
 
 export const propIs = curry(propIsFn)

package/src/propOr.js

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

package/src/propSatisfies.js

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

package/src/props.js

@@ -1,13 +1,13 @@
-import {_isArray} from './_internals/_isArray'
-import {mapArray} from './map'
+import { _isArray } from './_internals/_isArray.js'
+import { mapArray } from './map.js'
 
-export function props(propsToPick, obj) {
-  if (arguments.length === 1) {
+export function props(propsToPick, obj){
+  if (arguments.length === 1){
     return _obj => props(propsToPick, _obj)
   }
-  if (!_isArray(propsToPick)) {
+  if (!_isArray(propsToPick)){
     throw new Error('propsToPick is not a list')
   }
 
-  return mapArray(prop => obj[prop], propsToPick)
+  return mapArray(prop => obj[ prop ], propsToPick)
 }

package/src/range.js

@@ -1,7 +1,7 @@
-export function range(start, end) {
+export function range(start, end){
   if (arguments.length === 1) return _end => range(start, _end)
 
-  if (Number.isNaN(Number(start)) || Number.isNaN(Number(end))) {
+  if (Number.isNaN(Number(start)) || Number.isNaN(Number(end))){
     throw new TypeError('Both arguments to range must be numbers')
   }
 
@@ -10,8 +10,8 @@ export function range(start, end) {
   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; i++){
+    willReturn[ i ] = start + i
   }
 
   return willReturn

package/src/reduce.js

@@ -1,16 +1,20 @@
-import {_isArray} from './_internals/_isArray'
-import {_keys} from './_internals/_keys'
-import {curry} from './curry'
+import { _isArray } from './_internals/_isArray.js'
+import { _keys } from './_internals/_keys.js'
+import { curry } from './curry.js'
 
-function reduceFn(reducer, acc, list) {
-  if (!_isArray(list)) {
+export function reduceFn(
+  reducer, acc, list
+){
+  if (!_isArray(list)){
     throw new TypeError('reduce: list must be array or iterable')
   }
   let index = 0
   const len = list.length
 
-  while (index < len) {
-    acc = reducer(acc, list[index], index, list)
+  while (index < len){
+    acc = reducer(
+      acc, list[ index ], index, list
+    )
     index++
   }
 

package/src/reject.js

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

package/src/repeat.js

@@ -1,5 +1,5 @@
-export function repeat(x, timesToRepeat) {
-  if (arguments.length === 1) {
+export function repeat(x, timesToRepeat){
+  if (arguments.length === 1){
     return _timesToRepeat => repeat(x, _timesToRepeat)
   }
 

package/src/replace.js

@@ -1,6 +1,8 @@
-import {curry} from './curry'
+import { curry } from './curry.js'
 
-function replaceFn(pattern, replacer, str) {
+function replaceFn(
+  pattern, replacer, str
+){
   return str.replace(pattern, replacer)
 }
 

package/src/reverse.js

@@ -1,6 +1,7 @@
-export function reverse(listOrString) {
-  if (typeof listOrString === 'string') {
-    return listOrString.split('').reverse().join('')
+export function reverse(listOrString){
+  if (typeof listOrString === 'string'){
+    return listOrString.split('').reverse()
+      .join('')
   }
 
   const clone = listOrString.slice()

package/src/set.js

@@ -1,9 +1,13 @@
-import {always} from './always'
-import {curry} from './curry'
-import {over} from './over'
+import { always } from './always.js'
+import { curry } from './curry.js'
+import { over } from './over.js'
 
-function setFn(lens, replacer, x) {
-  return over(lens, always(replacer), x)
+function setFn(
+  lens, replacer, x
+){
+  return over(
+    lens, always(replacer), x
+  )
 }
 
 export const set = curry(setFn)

package/src/slice.js

@@ -1,6 +1,8 @@
-import {curry} from './curry'
+import { curry } from './curry.js'
 
-function sliceFn(from, to, list) {
+function sliceFn(
+  from, to, list
+){
   return list.slice(from, to)
 }
 

package/src/sort.js

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

package/src/sortBy.js

@@ -1,6 +1,6 @@
-import {cloneList} from './_internals/cloneList'
+import { cloneList } from './_internals/cloneList.js'
 
-export function sortBy(sortFn, list) {
+export function sortBy(sortFn, list){
   if (arguments.length === 1) return _list => sortBy(sortFn, _list)
 
   const clone = cloneList(list)

package/src/split.js

@@ -1,4 +1,4 @@
-export function split(separator, str) {
+export function split(separator, str){
   if (arguments.length === 1) return _str => split(separator, _str)
 
   return str.split(separator)

package/src/splitAt.js

@@ -1,15 +1,15 @@
-import {_isArray} from './_internals/_isArray'
-import {drop} from './drop'
-import {maybe} from './maybe'
-import {take} from './take'
+import { _isArray } from './_internals/_isArray.js'
+import { drop } from './drop.js'
+import { maybe } from './maybe.js'
+import { take } from './take.js'
 
-export function splitAt(index, input) {
-  if (arguments.length === 1) {
+export function splitAt(index, input){
+  if (arguments.length === 1){
     return _list => splitAt(index, _list)
   }
-  if (!input) throw new TypeError(`Cannot read property 'slice' of ${input}`)
+  if (!input) throw new TypeError(`Cannot read property 'slice' of ${ input }`)
 
-  if (!_isArray(input) && typeof input !== 'string') return [[], []]
+  if (!_isArray(input) && typeof input !== 'string') return [ [], [] ]
 
   const correctIndex = maybe(
     index < 0,
@@ -17,5 +17,5 @@ export function splitAt(index, input) {
     index
   )
 
-  return [take(correctIndex, input), drop(correctIndex, input)]
+  return [ take(correctIndex, input), drop(correctIndex, input) ]
 }

package/src/splitEvery.js

@@ -1,19 +1,17 @@
-export function splitEvery(sliceLength, listOrString) {
-  if (arguments.length === 1) {
+export function splitEvery(sliceLength, listOrString){
+  if (arguments.length === 1){
     return _listOrString => splitEvery(sliceLength, _listOrString)
   }
 
-  if (sliceLength < 1) {
-    throw new Error(
-      'First argument to splitEvery must be a positive integer'
-    )
+  if (sliceLength < 1){
+    throw new Error('First argument to splitEvery must be a positive integer')
   }
 
   const willReturn = []
   let counter = 0
 
-  while (counter < listOrString.length) {
-    willReturn.push(listOrString.slice(counter, (counter += sliceLength)))
+  while (counter < listOrString.length){
+    willReturn.push(listOrString.slice(counter, counter += sliceLength))
   }
 
   return willReturn

package/src/splitWhen.js

@@ -1,25 +1,25 @@
-export function splitWhen(predicate, input) {
-  if (arguments.length === 1) {
+export function splitWhen(predicate, input){
+  if (arguments.length === 1){
     return _input => splitWhen(predicate, _input)
   }
   if (!input)
-    throw new TypeError(`Cannot read property 'length' of ${input}`)
+    throw new TypeError(`Cannot read property 'length' of ${ input }`)
 
   const preFound = []
   const postFound = []
   let found = false
   let counter = -1
 
-  while (counter++ < input.length - 1) {
-    if (found) {
-      postFound.push(input[counter])
-    } else if (predicate(input[counter])) {
-      postFound.push(input[counter])
+  while (counter++ < input.length - 1){
+    if (found){
+      postFound.push(input[ counter ])
+    } else if (predicate(input[ counter ])){
+      postFound.push(input[ counter ])
       found = true
     } else {
-      preFound.push(input[counter])
+      preFound.push(input[ counter ])
     }
   }
 
-  return [preFound, postFound]
+  return [ preFound, postFound ]
 }

package/src/startsWith.js

@@ -1,11 +1,11 @@
-import {equals} from './equals.js'
-import {_isArray} from './_internals/_isArray.js'
+import { _isArray } from './_internals/_isArray.js'
+import { equals } from './equals.js'
 
-export function startsWith(target, iterable) {
+export function startsWith(target, iterable){
   if (arguments.length === 1)
     return _iterable => startsWith(target, _iterable)
 
-  if (typeof iterable === 'string') {
+  if (typeof iterable === 'string'){
     return iterable.startsWith(target)
   }
   if (!_isArray(target)) return false
@@ -13,8 +13,9 @@ export function startsWith(target, iterable) {
   let correct = true
   const filtered = target.filter((x, index) => {
     if (!correct) return false
-    const result = equals(x, iterable[index])
+    const result = equals(x, iterable[ index ])
     if (!result) correct = false
+
     return result
   })
 

package/src/subtract.js

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

package/src/sum.js

@@ -1,3 +1,3 @@
-export function sum(list) {
+export function sum(list){
   return list.reduce((prev, current) => prev + current, 0)
 }

package/src/symmetricDifference.js

@@ -1,14 +1,12 @@
-import {concat} from './concat'
-import {filter} from './filter'
-import {includes} from './includes'
+import { concat } from './concat.js'
+import { filter } from './filter.js'
+import { includes } from './includes.js'
 
-export function symmetricDifference(x, y) {
-  if (arguments.length === 1) {
+export function symmetricDifference(x, y){
+  if (arguments.length === 1){
     return _y => symmetricDifference(x, _y)
   }
 
-  return concat(
-    filter(value => !includes(value, y), x),
-    filter(value => !includes(value, x), y)
-  )
+  return concat(filter(value => !includes(value, y), x),
+    filter(value => !includes(value, x), y))
 }

package/src/tail.js

@@ -1,5 +1,5 @@
-import {drop} from './drop'
+import { drop } from './drop.js'
 
-export function tail(listOrString) {
+export function tail(listOrString){
   return drop(1, listOrString)
 }

package/src/take.js

@@ -1,10 +1,12 @@
-import baseSlice from './_internals/baseSlice'
+import baseSlice from './_internals/baseSlice.js'
 
-export function take(howMany, listOrString) {
+export function take(howMany, listOrString){
   if (arguments.length === 1)
     return _listOrString => take(howMany, _listOrString)
   if (howMany < 0) return listOrString.slice()
   if (typeof listOrString === 'string') return listOrString.slice(0, howMany)
 
-  return baseSlice(listOrString, 0, howMany)
+  return baseSlice(
+    listOrString, 0, howMany
+  )
 }

package/src/takeLast.js

@@ -1,6 +1,6 @@
-import baseSlice from './_internals/baseSlice'
+import baseSlice from './_internals/baseSlice.js'
 
-export function takeLast(howMany, listOrString) {
+export function takeLast(howMany, listOrString){
   if (arguments.length === 1)
     return _listOrString => takeLast(howMany, _listOrString)
 
@@ -13,5 +13,7 @@ export function takeLast(howMany, listOrString) {
 
   numValue = len - numValue
 
-  return baseSlice(listOrString, numValue, len)
+  return baseSlice(
+    listOrString, numValue, len
+  )
 }

package/src/takeLastWhile.js

@@ -1,7 +1,7 @@
-import {_isArray} from './_internals/_isArray'
+import { _isArray } from './_internals/_isArray.js'
 
-export function takeLastWhile(predicate, input) {
-  if (arguments.length === 1) {
+export function takeLastWhile(predicate, input){
+  if (arguments.length === 1){
     return _input => takeLastWhile(predicate, _input)
   }
   if (input.length === 0) return input
@@ -9,12 +9,12 @@ export function takeLastWhile(predicate, input) {
   const toReturn = []
   let counter = input.length
 
-  while (!found || counter === 0) {
+  while (!found || counter === 0){
     counter--
-    if (predicate(input[counter]) === false) {
+    if (predicate(input[ counter ]) === false){
       found = true
-    } else if (!found) {
-      toReturn.push(input[counter])
+    } else if (!found){
+      toReturn.push(input[ counter ])
     }
   }
 

package/src/takeWhile.js

@@ -1,22 +1,22 @@
-import {_isArray} from '../src/_internals/_isArray'
+import { _isArray } from '../src/_internals/_isArray.js'
 
-export function takeWhile(predicate, iterable) {
-  if (arguments.length === 1) {
+export function takeWhile(predicate, iterable){
+  if (arguments.length === 1){
     return _iterable => takeWhile(predicate, _iterable)
   }
   const isArray = _isArray(iterable)
-  if (!isArray && typeof iterable !== 'string') {
+  if (!isArray && typeof iterable !== 'string'){
     throw new Error('`iterable` is neither list nor a string')
   }
   let flag = true
   const holder = []
   let counter = -1
 
-  while (counter++ < iterable.length - 1) {
-    if (!predicate(iterable[counter])) {
+  while (counter++ < iterable.length - 1){
+    if (!predicate(iterable[ counter ])){
       if (flag) flag = false
-    } else if (flag) {
-      holder.push(iterable[counter])
+    } else if (flag){
+      holder.push(iterable[ counter ])
     }
   }
   holder

package/src/tap.js

@@ -1,4 +1,4 @@
-export function tap(fn, x) {
+export function tap(fn, x){
   if (arguments.length === 1) return _x => tap(fn, _x)
 
   fn(x)