rambda 9.4.2 → 10.0.0-beta.1

package/src/reduce.js

@@ -1,36 +1,21 @@
 import { isArray } from './_internals/isArray.js'
-import { curry } from './curry.js'
 
-class ReduceStopper{
-  constructor(value){
-    this.value = value
-  }
-}
-
-export function reduceFn(
-  reducer, acc, list
-){
-  if (list == null){
-    return acc
-  }
-  if (!isArray(list)){
-    throw new TypeError('reduce: list must be array or iterable')
-  }
-  let index = 0
-  const len = list.length
+export function reduce(reducer, acc) {
+  return list => {
+    if (list == null) {
+      return acc
+    }
+    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
-    )
-    if (acc instanceof ReduceStopper){
-      return acc.value
+    while (index < len) {
+      acc = reducer(acc, list[index], index, list)
+      index++
     }
-    index++
-  }
 
-  return acc
+    return acc
+  }
 }
-
-export const reduce = curry(reduceFn)
-export const reduceStopper = value => new ReduceStopper(value)

package/src/reject.js

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

package/src/rejectObject.js

@@ -0,0 +1,13 @@
+export function rejectObject(predicate) {
+  return obj => {
+    const willReturn = {}
+
+    for (const prop in obj) {
+      if (!predicate(obj[prop], prop, obj)) {
+        willReturn[prop] = obj[prop]
+      }
+    }
+
+    return willReturn
+  }
+}

package/src/replace.js

@@ -1,9 +1,3 @@
-import { curry } from './curry.js'
-
-function replaceFn(
-  pattern, replacer, str
-){
-  return str.replace(pattern, replacer)
+export function replace(pattern, replacer) {
+  return str => str.replace(pattern, replacer)
 }
-
-export const replace = curry(replaceFn)

package/src/replaceItemAtIndex.js

@@ -0,0 +1,15 @@
+import { cloneList } from './_internals/cloneList.js'
+
+export function replaceItemAtIndex(index, replaceFn) {
+  return list => {
+    const actualIndex = index < 0 ? list.length + index : index
+    if (index >= list.length || actualIndex < 0) {
+      return list
+    }
+
+    const clone = cloneList(list)
+    clone[actualIndex] = replaceFn(clone[actualIndex])
+
+    return clone
+  }
+}

package/src/shuffle.js

@@ -0,0 +1,13 @@
+export function shuffle(listInput) {
+  const list = cloneList(listInput)
+  let counter = list.length
+  while (counter > 0) {
+    const index = Math.floor(Math.random() * counter)
+    counter--
+    const temp = list[counter]
+    list[counter] = list[index]
+    list[index] = temp
+  }
+
+  return list
+}

package/src/sort.js

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

package/src/sortBy.js

@@ -1,16 +1,18 @@
 import { cloneList } from './_internals/cloneList.js'
 
-export function sortBy(sortFn, list){
-  if (arguments.length === 1) return _list => sortBy(sortFn, _list)
+export function sortBy(sortFn) {
+  return list => {
+    const clone = cloneList(list)
 
-  const clone = cloneList(list)
+    return clone.sort((a, b) => {
+      const aSortResult = sortFn(a)
+      const bSortResult = sortFn(b)
 
-  return clone.sort((a, b) => {
-    const aSortResult = sortFn(a)
-    const bSortResult = sortFn(b)
+      if (aSortResult === bSortResult) {
+        return 0
+      }
 
-    if (aSortResult === bSortResult) return 0
-
-    return aSortResult < bSortResult ? -1 : 1
-  })
+      return aSortResult < bSortResult ? -1 : 1
+    })
+  }
 }

package/src/sortObject.js

@@ -0,0 +1,15 @@
+import { sort } from './sort.js'
+
+export function sortObject(predicate) {
+  return obj => {
+    const keys = Object.keys(obj)
+    const sortedKeys = sort((a, b) => predicate(a, b, obj[a], obj[b]))(keys)
+
+    const toReturn = {}
+    sortedKeys.forEach(singleKey => {
+      toReturn[singleKey] = obj[singleKey]
+    })
+
+    return toReturn
+  }
+}

package/src/sortWith.js

@@ -1,27 +1,23 @@
-function sortHelper(
-  a, b, listOfSortingFns
-){
+function sortHelper(a, b, listOfSortingFns) {
   let result = 0
   let i = 0
-  while (result === 0 && i < listOfSortingFns.length){
-    result = listOfSortingFns[ i ](a, b)
+  while (result === 0 && i < listOfSortingFns.length) {
+    result = listOfSortingFns[i](a, b)
     i += 1
   }
 
   return result
 }
 
-export function sortWith(listOfSortingFns, list){
-  if (arguments.length === 1)
-    return _list => sortWith(listOfSortingFns, _list)
+export function sortWith(listOfSortingFns) {
+  return list => {
+    if (Array.isArray(list) === false) {
+      return []
+    }
 
-  if (Array.isArray(list) === false)
-    return []
+    const clone = list.slice()
+    clone.sort((a, b) => sortHelper(a, b, listOfSortingFns))
 
-  const clone = list.slice()
-  clone.sort((a, b) => sortHelper(
-    a, b, listOfSortingFns
-  ))
-
-  return clone
+    return clone
+  }
 }

package/src/split.js

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

package/src/splitEvery.js

@@ -1,18 +1,16 @@
-export function splitEvery(sliceLength, listOrString){
-  if (arguments.length === 1){
-    return _listOrString => splitEvery(sliceLength, _listOrString)
-  }
+export function splitEvery(sliceLength) {
+  return list => {
+    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
 
-  const willReturn = []
-  let counter = 0
+    while (counter < list.length) {
+      willReturn.push(list.slice(counter, (counter += sliceLength)))
+    }
 
-  while (counter < listOrString.length){
-    willReturn.push(listOrString.slice(counter, counter += sliceLength))
+    return willReturn
   }
-
-  return willReturn
 }

package/src/symmetricDifference.js

@@ -1,12 +1,9 @@
-import { concat } from './concat.js'
 import { filter } from './filter.js'
 import { includes } from './includes.js'
 
-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))
+export function symmetricDifference(x) {
+  return y => [
+    ...filter(value => !includes(value)(y))(x),
+    ...filter(value => !includes(value)(x))(y),
+  ]
 }

package/src/tail.js

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

package/src/take.js

@@ -1,12 +1,14 @@
-import baseSlice from './_internals/baseSlice.js'
+import { baseSlice } from './_internals/baseSlice.js'
 
-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)
+export function take(numberOfItems) {
+  return input => {
+    if (numberOfItems < 0) {
+      return input.slice()
+    }
+    if (typeof input === 'string') {
+      return input.slice(0, numberOfItems)
+    }
 
-  return baseSlice(
-    listOrString, 0, howMany
-  )
+    return baseSlice(input, 0, numberOfItems)
+  }
 }

package/src/takeLast.js

@@ -1,19 +1,19 @@
-import baseSlice from './_internals/baseSlice.js'
+import { baseSlice } from './_internals/baseSlice.js'
 
-export function takeLast(howMany, listOrString){
-  if (arguments.length === 1)
-    return _listOrString => takeLast(howMany, _listOrString)
+export function takeLast(numberOfItems) {
+  return input => {
+    const len = input.length
+    if (numberOfItems < 0) {
+      return input.slice()
+    }
+    let numValue = numberOfItems > len ? len : numberOfItems
 
-  const len = listOrString.length
-  if (howMany < 0) return listOrString.slice()
-  let numValue = howMany > len ? len : howMany
+    if (typeof input === 'string') {
+      return input.slice(len - numValue)
+    }
 
-  if (typeof listOrString === 'string')
-    return listOrString.slice(len - numValue)
+    numValue = len - numValue
 
-  numValue = len - numValue
-
-  return baseSlice(
-    listOrString, numValue, len
-  )
+    return baseSlice(input, numValue, len)
+  }
 }

package/src/takeLastWhile.js

@@ -1,21 +1,20 @@
-import { isArray } from './_internals/isArray.js'
-
-export function takeLastWhile(predicate, input){
-  if (arguments.length === 1){
-    return _input => takeLastWhile(predicate, _input)
-  }
-  if (input.length === 0) return input
+export function takeLastWhile(predicate) {
+  return input => {
+    if (input.length === 0) {
+      return input
+    }
 
-  const toReturn = []
-  let counter = input.length
+    const toReturn = []
+    let counter = input.length
 
-  while (counter){
-    const item = input[ --counter ]
-    if (!predicate(item)){
-      break
+    while (counter) {
+      const item = input[--counter]
+      if (!predicate(item)) {
+        break
+      }
+      toReturn.push(item)
     }
-    toReturn.push(item)
-  }
 
-  return isArray(input) ? toReturn.reverse() : toReturn.reverse().join('')
+    return toReturn.reverse()
+  }
 }

package/src/takeWhile.js

@@ -1,24 +1,15 @@
-import { isArray as isArrayModule } from './_internals/isArray.js'
-
-export function takeWhile(predicate, iterable){
-  if (arguments.length === 1){
-    return _iterable => takeWhile(predicate, _iterable)
-  }
-  const isArray = isArrayModule(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)){
-      break
+export function takeWhile(predicate) {
+  return iterable => {
+    const toReturn = []
+    let counter = 0
+
+    while (counter < iterable.length) {
+      const item = iterable[counter++]
+      if (!predicate(item)) {
+        break
+      }
+      toReturn.push(item)
     }
-    toReturn.push(item)
+    return toReturn
   }
-
-  return isArray ? toReturn : toReturn.join('')
 }

package/src/tap.js

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

package/src/test.js

@@ -1,9 +1,3 @@
-export function test(pattern, str){
-  if (arguments.length === 1) return _str => test(pattern, _str)
-
-  if (typeof pattern === 'string'){
-    throw new TypeError(`R.test requires a value of type RegExp as its first argument; received "${ pattern }"`)
-  }
-
-  return str.search(pattern) !== -1
+export function test(pattern) {
+  return str => str.search(pattern) !== -1
 }

package/src/tryCatch.js

@@ -1,18 +1,9 @@
-import { type } from './type.js'
-
-const isFunction = x => [ 'Promise', 'Function' ].includes(type(x))
-
-export function tryCatch(fn, fallback){
-  if (!isFunction(fn)){
-    throw new Error(`R.tryCatch | fn '${ fn }'`)
-  }
-  const passFallback = isFunction(fallback)
-
-  return (...inputs) => {
+export function tryCatch(fn, fallback) {
+  return input => {
     try {
-      return fn(...inputs)
-    } catch (e){
-      return passFallback ? fallback(e, ...inputs) : fallback
+      return fn(input)
+    } catch (e) {
+      return fallback
     }
   }
 }

package/src/type.js

@@ -1,12 +1,13 @@
-export function type(input){
-  if (input === null){
+export function type(input) {
+  if (input === null) {
     return 'Null'
-  } else if (input === undefined){
+  }
+  if (input === undefined) {
     return 'Undefined'
-  } else if (Number.isNaN(input)){
+  }
+  if (Number.isNaN(input)) {
     return 'NaN'
   }
   const typeResult = Object.prototype.toString.call(input).slice(8, -1)
-
   return typeResult === 'AsyncFunction' ? 'Promise' : typeResult
 }

package/src/union.js

@@ -1,14 +1,16 @@
 import { cloneList } from './_internals/cloneList.js'
 import { includes } from './includes.js'
 
-export function union(x, y){
-  if (arguments.length === 1) return _y => union(x, _y)
+export function union(x) {
+  return y => {
+    const toReturn = cloneList(x)
 
-  const toReturn = cloneList(x)
+    y.forEach(yInstance => {
+      if (!includes(yInstance)(x)) {
+        toReturn.push(yInstance)
+      }
+    })
 
-  y.forEach(yInstance => {
-    if (!includes(yInstance, x)) toReturn.push(yInstance)
-  })
-
-  return toReturn
+    return toReturn
+  }
 }

package/src/uniq.js

@@ -1,10 +1,10 @@
 import { _Set } from './_internals/set.js'
 
-export function uniq(list){
+export function uniq(list) {
   const set = new _Set()
   const willReturn = []
   list.forEach(item => {
-    if (set.checkUniqueness(item)){
+    if (set.checkUniqueness(item)) {
       willReturn.push(item)
     }
   })

package/src/uniqBy.js

@@ -1,10 +1,9 @@
 import { _Set } from '../src/_internals/set.js'
 
-export function uniqBy(fn, list){
-  if (arguments.length === 1){
-    return _list => uniqBy(fn, _list)
-  }
-  const set = new _Set()
+export function uniqBy(fn) {
+  return list => {
+    const set = new _Set()
 
-  return list.filter(item => set.checkUniqueness(fn(item)))
+    return list.filter(item => set.checkUniqueness(fn(item)))
+  }
 }

package/src/uniqWith.js

@@ -1,13 +1,11 @@
-function includesWith(
-  predicate, target, list
-){
+function includesWith(predicate, target, list) {
   let willReturn = false
   let index = -1
 
-  while (++index < list.length && !willReturn){
-    const value = list[ index ]
+  while (++index < list.length && !willReturn) {
+    const value = list[index]
 
-    if (predicate(target, value)){
+    if (predicate(target, value)) {
       willReturn = true
     }
   }
@@ -15,21 +13,19 @@ function includesWith(
   return willReturn
 }
 
-export function uniqWith(predicate, list){
-  if (arguments.length === 1) return _list => uniqWith(predicate, _list)
+export function uniqWith(predicate) {
+  return list => {
+    let index = -1
+    const willReturn = []
 
-  let index = -1
-  const willReturn = []
-
-  while (++index < list.length){
-    const value = list[ index ]
+    while (++index < list.length) {
+      const value = list[index]
 
-    if (!includesWith(
-      predicate, value, willReturn
-    )){
-      willReturn.push(value)
+      if (!includesWith(predicate, value, willReturn)) {
+        willReturn.push(value)
+      }
     }
-  }
 
-  return willReturn
+    return willReturn
+  }
 }

package/src/unless.js

@@ -1,11 +1,9 @@
-import { curry } from './curry.js'
+export function unless(predicate, whenFalseFn) {
+  return input => {
+    if (predicate(input)) {
+      return input
+    }
 
-function unlessFn(
-  predicate, whenFalseFn, input
-){
-  if (predicate(input)) return input
-
-  return whenFalseFn(input)
+    return whenFalseFn(input)
+  }
 }
-
-export const unless = curry(unlessFn)

package/src/unwind.js

@@ -1,16 +1,8 @@
-import { isArray } from './_internals/isArray.js'
-import { mapArray } from './map.js'
-
-export function unwind(property, obj){
-  if (arguments.length === 1){
-    return _obj => unwind(property, _obj)
+export function unwind(property) {
+  return obj => {
+    return obj[property].map(x => ({
+      ...obj,
+      [property]: x,
+    }))
   }
-
-  if (!isArray(obj[ property ])) return [ obj ]
-
-  return mapArray(x => ({
-    ...obj,
-    [ property ] : x,
-  }),
-  obj[ property ])
 }