rambda 8.1.0 → 8.3.0

package/src/_internals/_arity.js

@@ -0,0 +1,64 @@
+export 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)
+    }
+  }
+}

package/src/_internals/utils.js

@@ -0,0 +1,21 @@
+export function _concat(set1, set2){
+  set1 = set1 || []
+  set2 = set2 || []
+  let idx
+  const len1 = set1.length
+  const len2 = set2.length
+  const result = []
+
+  idx = 0
+  while (idx < len1){
+    result[ result.length ] = set1[ idx ]
+    idx += 1
+  }
+  idx = 0
+  while (idx < len2){
+    result[ result.length ] = set2[ idx ]
+    idx += 1
+  }
+
+  return result
+}

package/src/addIndex.js

@@ -0,0 +1,23 @@
+import { _concat } from './_internals/utils.js'
+import { curryN } from './curryN.js'
+
+export function addIndex(
+  originalFunction,
+  initialIndexFn = () => 0,
+  loopIndexChange = x => x + 1
+){
+  return curryN(originalFunction.length, function (){
+    const origFn = arguments[ 0 ]
+    const list = arguments[ arguments.length - 1 ]
+    let idx = initialIndexFn(list.length)
+    const args = Array.prototype.slice.call(arguments, 0)
+    args[ 0 ] = function (){
+      const result = origFn.apply(this, _concat(arguments, [ idx, list ]))
+      idx = loopIndexChange(idx)
+
+      return result
+    }
+
+    return originalFunction.apply(this, args)
+  })
+}

package/src/addIndexRight.js

@@ -0,0 +1,9 @@
+import { addIndex } from './addIndex.js'
+
+export function addIndexRight(originalFunction){
+  return addIndex(
+    originalFunction,
+    listLength => listLength - 1,
+    x => x - 1
+  )
+}

package/src/ap.js

@@ -0,0 +1,7 @@
+export function ap(functions, input){
+  if (arguments.length === 1){
+    return _inputs => ap(functions, _inputs)
+  }
+
+  return functions.reduce((acc, fn) => [ ...acc, ...input.map(fn) ], [])
+}

package/src/aperture.js

@@ -0,0 +1,15 @@
+export function aperture(step, list){
+  if (arguments.length === 1){
+    return _list => aperture(step, _list)
+  }
+  if (step > list.length) return []
+  let idx = 0
+  const limit = list.length - (step - 1)
+  const acc = new Array(limit)
+  while (idx < limit){
+    acc[ idx ] = list.slice(idx, idx + step)
+    idx += 1
+  }
+
+  return acc
+}

package/src/applyTo.js

@@ -0,0 +1,7 @@
+export function applyTo(input, fn){
+  if (arguments.length === 1){
+    return _fn => applyTo(input, _fn)
+  }
+
+  return fn(input)
+}

package/src/ascend.js

@@ -0,0 +1,23 @@
+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
+    )
+  }
+  const aValue = getFunction(a)
+  const bValue = getFunction(b)
+
+  return createCompareFunction(
+    aValue, bValue, -1, 1
+  )
+}

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

@@ -0,0 +1,17 @@
+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)
+
+  return createCompareFunction(
+    aValue, bValue, 1, -1
+  )
+}

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))