rambda 9.4.2 → 10.0.0-alpha.0

package/src/findIndex.js

@@ -1,14 +1,14 @@
-export function findIndex(predicate, list){
-  if (arguments.length === 1) return _list => findIndex(predicate, _list)
-
+export function findIndex(predicate) {
+	return list => {
   const len = list.length
   let index = -1
 
-  while (++index < len){
-    if (predicate(list[ index ])){
+  while (++index < len) {
+    if (predicate(list[index])) {
       return index
     }
   }
 
   return -1
 }
+}

package/src/findLast.js

@@ -1,13 +1,13 @@
-export function findLast(predicate, list){
-  if (arguments.length === 1) return _list => findLast(predicate, _list)
-
+export function findLast(predicate) {
+	return list => {
   let index = list.length
 
-  while (--index >= 0){
-    if (predicate(list[ index ])){
-      return list[ index ]
+  while (--index >= 0) {
+    if (predicate(list[index])) {
+      return list[index]
     }
   }
 
   return undefined
 }
+}

package/src/findLastIndex.js

@@ -1,13 +1,13 @@
-export function findLastIndex(fn, list){
-  if (arguments.length === 1) return _list => findLastIndex(fn, _list)
-
+export function findLastIndex(fn) {
+	return list => {
   let index = list.length
 
-  while (--index >= 0){
-    if (fn(list[ index ])){
+  while (--index >= 0) {
+    if (fn(list[index])) {
       return index
     }
   }
 
   return -1
 }
+}

package/src/flatMap.js

@@ -0,0 +1,3 @@
+export function flatMap(fn) {
+  return list => [].concat(...list.map(fn))
+}

package/src/flatten.js

@@ -1,13 +1,13 @@
 import { isArray } from './_internals/isArray.js'
 
-export function flatten(list, input){
+export function flatten(list, input) {
   const willReturn = input === undefined ? [] : input
 
-  for (let i = 0; i < list.length; i++){
-    if (isArray(list[ i ])){
-      flatten(list[ i ], willReturn)
+  for (let i = 0; i < list.length; i++) {
+    if (isArray(list[i])) {
+      flatten(list[i], willReturn)
     } else {
-      willReturn.push(list[ i ])
+      willReturn.push(list[i])
     }
   }
 

package/src/groupBy.js

@@ -1,16 +1,18 @@
-export function groupBy(groupFn, list){
-  if (arguments.length === 1) return _list => groupBy(groupFn, _list)
+export function groupBy(groupFn, list) {
+  if (arguments.length === 1) {
+    return _list => groupBy(groupFn, _list)
+  }
 
   const result = {}
-  for (let i = 0; i < list.length; i++){
-    const item = list[ i ]
+  for (let i = 0; i < list.length; i++) {
+    const item = list[i]
     const key = groupFn(item)
 
-    if (!result[ key ]){
-      result[ key ] = []
+    if (!result[key]) {
+      result[key] = []
     }
 
-    result[ key ].push(item)
+    result[key].push(item)
   }
 
   return result

package/src/head.js

@@ -1,5 +1,7 @@
-export function head(listOrString){
-  if (typeof listOrString === 'string') return listOrString[ 0 ] || ''
+export function head(listOrString) {
+  if (typeof listOrString === 'string') {
+    return listOrString[0] || ''
+  }
 
-  return listOrString[ 0 ]
+  return listOrString[0]
 }

package/src/includes.js

@@ -1,16 +1,19 @@
 import { isArray } from './_internals/isArray.js'
 import { _indexOf } from './equals.js'
 
-export function includes(valueToFind, iterable){
-  if (arguments.length === 1)
-    return _iterable => includes(valueToFind, _iterable)
-  if (typeof iterable === 'string'){
+export function includes(valueToFind) {
+	return iterable => 
+	{
+  if (typeof iterable === 'string') {
     return iterable.includes(valueToFind)
   }
-  if (!iterable){
-    throw new TypeError(`Cannot read property \'indexOf\' of ${ iterable }`)
+  if (!iterable) {
+    throw new TypeError(`Cannot read property \'indexOf\' of ${iterable}`)
+  }
+  if (!isArray(iterable)) {
+    return false
   }
-  if (!isArray(iterable)) return false
 
   return _indexOf(valueToFind, iterable) > -1
 }
+}

package/src/indexOf.js

@@ -1,9 +1,5 @@
 import { _indexOf } from './equals.js'
 
-export function indexOf(valueToFind, list){
-  if (arguments.length === 1){
-    return _list => _indexOf(valueToFind, _list)
-  }
-
-  return _indexOf(valueToFind, list)
+export function indexOf(valueToFind) {
+  return list => _indexOf(valueToFind, list)
 }

package/src/init.js

@@ -1,11 +1,9 @@
-import baseSlice from './_internals/baseSlice.js'
+import { baseSlice } from './_internals/baseSlice.js'
 
-export function init(listOrString){
-  if (typeof listOrString === 'string') return listOrString.slice(0, -1)
+export function init(input) {
+  if (typeof input === 'string') {
+    return input.slice(0, -1)
+  }
 
-  return listOrString.length ?
-    baseSlice(
-      listOrString, 0, -1
-    ) :
-    []
+  return input.length ? baseSlice(input, 0, -1) : []
 }

package/src/innerJoin.js

@@ -1,28 +1,26 @@
-import { curry } from './curry.js'
-
-function _includesWith(
-  pred, x, list
-){
+function _includesWith(pred, x, list) {
   let idx = 0
   const len = list.length
 
-  while (idx < len){
-    if (pred(x, list[ idx ]))
+  while (idx < len) {
+    if (pred(x, list[idx])) {
       return true
+    }
 
     idx += 1
   }
 
   return false
 }
-function _filter(fn, list){
+function _filter(fn, list) {
   let idx = 0
   const len = list.length
   const result = []
 
-  while (idx < len){
-    if (fn(list[ idx ]))
-      result[ result.length ] = list[ idx ]
+  while (idx < len) {
+    if (fn(list[idx])) {
+      result[result.length] = list[idx]
+    }
 
     idx += 1
   }
@@ -30,12 +28,6 @@ function _filter(fn, list){
   return result
 }
 
-export function innerJoinFn(
-  pred, xs, ys
-){
-  return _filter(x => _includesWith(
-    pred, x, ys
-  ), xs)
+export function innerJoin(pred, xs) {
+  return ys => _filter(x => _includesWith(pred, x, ys), xs)
 }
-
-export const innerJoin = curry(innerJoinFn)

package/src/intersection.js

@@ -1,8 +1,6 @@
 import { filter } from './filter.js'
 import { includes } from './includes.js'
 
-export function intersection(listA, listB){
-  if (arguments.length === 1) return _list => intersection(listA, _list)
-
-  return filter(x => includes(x, listA), listB)
+export function intersection(listA) {
+  return listB =>filter(x => includes(x)(listA))(listB)
 }

package/src/intersperse.js

@@ -1,17 +1,17 @@
-export function intersperse(separator, list){
-  if (arguments.length === 1) return _list => intersperse(separator, _list)
-
+export function intersperse(separator) {
+	return list => {
   let index = -1
   const len = list.length
   const willReturn = []
 
-  while (++index < len){
-    if (index === len - 1){
-      willReturn.push(list[ index ])
+  while (++index < len) {
+    if (index === len - 1) {
+      willReturn.push(list[index])
     } else {
-      willReturn.push(list[ index ], separator)
+      willReturn.push(list[index], separator)
     }
   }
 
   return willReturn
 }
+}

package/src/join.js

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

package/src/last.js

@@ -1,7 +1,7 @@
-export function last(listOrString){
-  if (typeof listOrString === 'string'){
-    return listOrString[ listOrString.length - 1 ] || ''
+export function last(listOrString) {
+  if (typeof listOrString === 'string') {
+    return listOrString[listOrString.length - 1] || ''
   }
 
-  return listOrString[ listOrString.length - 1 ]
+  return listOrString[listOrString.length - 1]
 }

package/src/lastIndexOf.js

@@ -1,9 +1,5 @@
 import { _lastIndexOf } from './equals.js'
 
-export function lastIndexOf(valueToFind, list){
-  if (arguments.length === 1){
-    return _list => _lastIndexOf(valueToFind, _list)
-  }
-
-  return _lastIndexOf(valueToFind, list)
+export function lastIndexOf(valueToFind) {
+  return list => _lastIndexOf(valueToFind, list)
 }

package/src/map.js

@@ -1,51 +1,11 @@
-import { INCORRECT_ITERABLE_INPUT } from './_internals/constants.js'
-import { isArray } from './_internals/isArray.js'
-import { keys } from './_internals/keys.js'
-
-export function mapArray(
-  fn, list, isIndexed = false
-){
-  let index = 0
-  const willReturn = Array(list.length)
-
-  while (index < list.length){
-    willReturn[ index ] = isIndexed ? fn(list[ index ], index) : fn(list[ index ])
-
-    index++
+export function map(fn) {
+  return list => {
+    let index = 0
+    const willReturn = Array(list.length)
+    while (index < list.length) {
+      willReturn[index] = fn(list[index], index)
+      index++
+    }
+    return willReturn
   }
-
-  return willReturn
-}
-
-export function mapObject(fn, obj){
-  if (arguments.length === 1){
-    return _obj => mapObject(fn, _obj)
-  }
-  let index = 0
-  const objKeys = keys(obj)
-  const len = objKeys.length
-  const willReturn = {}
-
-  while (index < len){
-    const key = objKeys[ index ]
-    willReturn[ key ] = fn(
-      obj[ key ], key, obj
-    )
-    index++
-  }
-
-  return willReturn
-}
-
-export const mapObjIndexed = mapObject
-
-export function map(fn, iterable){
-  if (arguments.length === 1) return _iterable => map(fn, _iterable)
-  if (!iterable){
-    throw new Error(INCORRECT_ITERABLE_INPUT)
-  }
-
-  if (isArray(iterable)) return mapArray(fn, iterable)
-
-  return mapObject(fn, iterable)
 }

package/src/mapAsync.js

@@ -0,0 +1,11 @@
+export function mapAsync(fn) {
+	return async list => {
+		const willReturn = []
+    let i = 0
+    for (const a of list) {
+      willReturn.push(await fn(a, i++))
+    }
+
+    return willReturn
+	}
+}

package/src/mapObject.js

@@ -0,0 +1,18 @@
+import { keys } from './_internals/keys.js'
+
+export function mapObject(fn) {
+  return obj => {
+    let index = 0
+    const objKeys = keys(obj)
+    const len = objKeys.length
+    const willReturn = {}
+
+    while (index < len) {
+      const key = objKeys[index]
+      willReturn[key] = fn(obj[key], key, obj)
+      index++
+    }
+
+    return willReturn
+  }
+}

package/src/mapObjectAsync.js

@@ -0,0 +1,10 @@
+export function mapObjectAsync(fn) {
+	return async obj => {
+		const willReturn = {}
+		for (const prop in obj){
+			willReturn[ prop ] = await fn(obj[ prop ], prop)
+		}
+	
+		return willReturn
+	}
+}

package/src/match.js

@@ -1,7 +1,7 @@
-export function match(pattern, input){
-  if (arguments.length === 1) return _input => match(pattern, _input)
-
-  const willReturn = input.match(pattern)
-
-  return willReturn === null ? [] : willReturn
+export function match(pattern) {
+	return input => {
+		const willReturn = input.match(pattern)
+	
+		return willReturn === null ? [] : willReturn
+	}
 }

package/src/maxBy.js

@@ -1,9 +1,3 @@
-import { curry } from './curry.js'
-
-export function maxByFn(
-  compareFn, x, y
-){
-  return compareFn(y) > compareFn(x) ? y : x
+export function maxBy(compareFn, x) {
+  return y => (compareFn(y) > compareFn(x) ? y : x)
 }
-
-export const maxBy = curry(maxByFn)

package/src/merge.js

@@ -1 +1,4 @@
-export { mergeRight as merge } from './mergeRight.js'
+export function merge(target) {
+  return objectWithNewProps =>
+    Object.assign({}, target || {}, objectWithNewProps || {})
+}

package/src/mergeTypes.js

@@ -0,0 +1,3 @@
+export function mergeTypes(x) {
+  return x
+}

package/src/minBy.js

@@ -1,9 +1,3 @@
-import { curry } from './curry.js'
-
-export function minByFn(
-  compareFn, x, y
-){
-  return compareFn(y) < compareFn(x) ? y : x
+export function minBy(compareFn, x) {
+  return y => (compareFn(y) < compareFn(x) ? y : x)
 }
-
-export const minBy = curry(minByFn)

package/src/modifyPath.js

@@ -1,33 +1,30 @@
 import { createPath } from './_internals/createPath.js'
-import { isArray } from './_internals/isArray.js'
-import { assoc } from './assoc.js'
-import { curry } from './curry.js'
 import { path as pathModule } from './path.js'
 
-export function modifyPathFn(
-  pathInput, fn, object
-){
-  const path = createPath(pathInput)
-  if (path.length === 1){
-    return {
-      ...object,
-      [ path[ 0 ] ] : fn(object[ path[ 0 ] ]),
+function assoc(prop, newValue) {
+  return obj => Object.assign({}, obj, { [prop]: newValue })
+}
+
+function modifyPathFn(pathInput, fn, obj) {
+    const path = createPath(pathInput)
+    if (path.length === 1) {
+      return {
+        ...obj,
+        [path[0]]: fn(obj[path[0]]),
+      }
+    }
+    if (pathModule(path)(obj) === undefined) {
+      return obj
     }
-  }
-  if (pathModule(path, object) === undefined) return object
 
-  const val = modifyPath(
-    Array.prototype.slice.call(path, 1),
-    fn,
-    object[ path[ 0 ] ]
-  )
-  if (val === object[ path[ 0 ] ]){
-    return object
-  }
+    const val = modifyPathFn(Array.prototype.slice.call(path, 1), fn, obj[path[0]])
+    if (val === obj[path[0]]) {
+      return obj
+    }
 
-  return assoc(
-    path[ 0 ], val, object
-  )
+    return assoc(path[0], val)(obj)
 }
 
-export const modifyPath = curry(modifyPathFn)
+export function modifyPath(pathInput, fn) {
+  return obj => modifyPathFn(pathInput, fn, obj)
+}

package/src/none.js

@@ -1,9 +1,11 @@
-export function none(predicate, list){
-  if (arguments.length === 1) return _list => none(predicate, _list)
+export function none(predicate) {
+  return list => {
+    for (let i = 0; i < list.length; i++) {
+      if (predicate(list[i])) {
+        return false
+      }
+    }
 
-  for (let i = 0; i < list.length; i++){
-    if (predicate(list[ i ])) return false
+    return true
   }
-
-  return true
 }

package/src/objOf.js

@@ -1,7 +1,3 @@
-export function objOf(key, value){
-  if (arguments.length === 1){
-    return _value => objOf(key, _value)
-  }
-
-  return { [ key ] : value }
+export function objOf(key) {
+  return value => ({ [key]: value })
 }

package/src/omit.js

@@ -1,18 +1,33 @@
 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)
+export function _includes(x, list) {
+  let index = -1
+  const { length } = list
 
-  if (obj === null || obj === undefined)
-    return undefined
+  while (++index < length) {
+    if (String(list[index]) === String(x)) {
+      return true
+    }
+  }
 
-  const propsToOmitValue = createPath(propsToOmit, ',')
-  const willReturn = {}
+  return false
+}
+
+export function omit(propsToOmit) {
+  return obj => {
+    if (!obj) {
+      return undefined
+    }
+
+    const propsToOmitValue = createPath(propsToOmit, ',')
+    const willReturn = {}
 
-  for (const key in obj)
-    if (!includes(key, propsToOmitValue))
-      willReturn[ key ] = obj[ key ]
+    for (const key in obj) {
+      if (!_includes(key, propsToOmitValue)) {
+        willReturn[key] = obj[key]
+      }
+    }
 
-  return willReturn
+    return willReturn
+  }
 }

package/src/partition.js

@@ -1,44 +1,41 @@
 import { isArray } from './_internals/isArray.js'
 
-export function partitionObject(predicate, iterable){
+export function partitionObject(predicate, iterable) {
   const yes = {}
   const no = {}
-  Object.entries(iterable).forEach(([ prop, value ]) => {
-    if (predicate(value, prop)){
-      yes[ prop ] = value
+  Object.entries(iterable).forEach(([prop, value]) => {
+    if (predicate(value, prop)) {
+      yes[prop] = value
     } else {
-      no[ prop ] = value
+      no[prop] = value
     }
   })
 
-  return [ yes, no ]
+  return [yes, no]
 }
 
-export function partitionArray(
-  predicate, list, indexed = false
-){
+export function partitionArray(predicate, list, indexed = false) {
   const yes = []
   const no = []
   let counter = -1
 
-  while (counter++ < list.length - 1){
-    if (
-      indexed ? predicate(list[ counter ], counter) : predicate(list[ counter ])
-    ){
-      yes.push(list[ counter ])
+  while (counter++ < list.length - 1) {
+    if (indexed ? predicate(list[counter], counter) : predicate(list[counter])) {
+      yes.push(list[counter])
     } else {
-      no.push(list[ counter ])
+      no.push(list[counter])
     }
   }
 
-  return [ yes, no ]
+  return [yes, no]
 }
 
-export function partition(predicate, iterable){
-  if (arguments.length === 1){
-    return listHolder => partition(predicate, listHolder)
-  }
-  if (!isArray(iterable)) return partitionObject(predicate, iterable)
-
-  return partitionArray(predicate, iterable)
+export function partition(predicate) {
+	return iterable => {
+		if (!isArray(iterable)) {
+			return partitionObject(predicate, iterable)
+		}
+	
+		return partitionArray(predicate, iterable)
+	}
 }