rambda 9.4.2 → 10.0.0-beta.1

package/src/evolve.js

@@ -1,60 +1,6 @@
-import { isArray } from './_internals/isArray.js'
-import { mapArray, mapObject } from './map.js'
+import { mapObject } from './mapObject.js'
 import { type } from './type.js'
 
-export function evolveArray(rules, list){
-  return mapArray(
-    (x, i) => {
-      if (type(rules[ i ]) === 'Function'){
-        return rules[ i ](x)
-      }
-
-      return x
-    },
-    list,
-    true
-  )
-}
-
-export function evolveObject(rules, iterable){
-  return mapObject((x, prop) => {
-    if (type(x) === 'Object'){
-      const typeRule = type(rules[ prop ])
-      if (typeRule === 'Function'){
-        return rules[ prop ](x)
-      }
-      if (typeRule === 'Object'){
-        return evolve(rules[ prop ], x)
-      }
-
-      return x
-    }
-    if (type(rules[ prop ]) === 'Function'){
-      return rules[ prop ](x)
-    }
-
-    return x
-  }, iterable)
-}
-
-export function evolve(rules, iterable){
-  if (arguments.length === 1){
-    return _iterable => evolve(rules, _iterable)
-  }
-  const rulesType = type(rules)
-  const iterableType = type(iterable)
-
-  if (iterableType !== rulesType){
-    throw new Error('iterableType !== rulesType')
-  }
-
-  if (![ 'Object', 'Array' ].includes(rulesType)){
-    throw new Error(`'iterable' and 'rules' are from wrong type ${ rulesType }`)
-  }
-
-  if (iterableType === 'Object'){
-    return evolveObject(rules, iterable)
-  }
-
-  return evolveArray(rules, iterable)
+export function evolve(rules) {
+  return mapObject((x, prop) => type(rules[prop]) === 'Function' ? rules[prop](x): x)
 }

package/src/excludes.js

@@ -0,0 +1,5 @@
+import { includes } from './includes.js'
+
+export function excludes(valueToFind) {
+  return iterable => !includes(valueToFind)(iterable)
+}

package/src/filter.js

@@ -1,50 +1,20 @@
-import { isArray } from './_internals/isArray.js'
-
-export function filterObject(predicate, obj){
-  const willReturn = {}
-
-  for (const prop in obj){
-    if (predicate(
-      obj[ prop ], prop, obj
-    )){
-      willReturn[ prop ] = obj[ prop ]
+export function filter(predicate) {
+  return list => {
+    if (!list) {
+      throw new Error('Incorrect iterable input')
     }
-  }
+    let index = 0
+    const len = list.length
+    const willReturn = []
 
-  return willReturn
-}
-
-export function filterArray(
-  predicate, list, indexed = false
-){
-  let index = 0
-  const len = list.length
-  const willReturn = []
+    while (index < len) {
+      if (predicate(list[index], index)) {
+        willReturn.push(list[index])
+      }
 
-  while (index < len){
-    const predicateResult = indexed ?
-      predicate(list[ index ], index) :
-      predicate(list[ index ])
-    if (predicateResult){
-      willReturn.push(list[ index ])
+      index++
     }
 
-    index++
+    return willReturn
   }
-
-  return willReturn
-}
-
-export function filter(predicate, iterable){
-  if (arguments.length === 1)
-    return _iterable => filter(predicate, _iterable)
-  if (!iterable){
-    throw new Error('Incorrect iterable input')
-  }
-
-  if (isArray(iterable)) return filterArray(
-    predicate, iterable, false
-  )
-
-  return filterObject(predicate, iterable)
 }

package/src/filterObject.js

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

package/src/find.js

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

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
 
-  const len = list.length
-  let index = -1
-
-  while (++index < len){
-    if (predicate(list[ index ])){
-      return index
+    while (++index < len) {
+      if (predicate(list[index])) {
+        return index
+      }
     }
-  }
 
-  return -1
+    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
 
-  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
+    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
 
-  let index = list.length
-
-  while (--index >= 0){
-    if (fn(list[ index ])){
-      return index
+    while (--index >= 0) {
+      if (fn(list[index])) {
+        return index
+      }
     }
-  }
 
-  return -1
+    return -1
+  }
 }

package/src/findNth.js

@@ -0,0 +1,16 @@
+export function findNth(predicate, nth) {
+  return list => {
+    let index = 0
+    const len = list.length
+
+    while (index < len) {
+      const x = list[index]
+      if (predicate(x)) {
+				if (nth === 0) return x
+				nth--
+      }
+
+      index++
+    }
+  }
+}

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,17 +1,20 @@
-export function groupBy(groupFn, list){
-  if (arguments.length === 1) return _list => groupBy(groupFn, _list)
+export function groupByFallback(groupFn, list) {
+    const result = {}
+    for (let i = 0; i < list.length; i++) {
+      const item = list[i]
+      const key = groupFn(item)
 
-  const result = {}
-  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
+}
+
 
-  return result
+export function groupBy(groupFn) {
+  return iterable => Object.groupBy ? Object.groupBy(iterable,groupFn) : groupByFallback(groupFn, iterable)
 }

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,18 @@
 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'){
-    return iterable.includes(valueToFind)
-  }
-  if (!iterable){
-    throw new TypeError(`Cannot read property \'indexOf\' of ${ iterable }`)
-  }
-  if (!isArray(iterable)) return false
+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 (!isArray(iterable)) {
+      return false
+    }
 
-  return _indexOf(valueToFind, iterable) > -1
+    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/interpolate.js

@@ -0,0 +1,29 @@
+const getOccurrences = input => input.match(/{{\s*.+?\s*}}/g)
+const getOccurrenceProp = occurrence => occurrence.replace(/{{\s*|\s*}}/g, '')
+
+const replace = ({ inputHolder, prop, replacer }) => {
+  const regexBase = `{{${prop}}}`
+  const regex = new RegExp(regexBase, 'g')
+  return inputHolder.replace(regex, replacer)
+}
+
+export function interpolate(input) {
+  return templateInput => {
+    const occurrences = getOccurrences(input)
+    if (occurrences === null) {
+      return input
+    }
+    let inputHolder = input
+
+    for (const occurrence of occurrences) {
+      const prop = getOccurrenceProp(occurrence)
+      inputHolder = replace({
+        inputHolder,
+        prop,
+        replacer: templateInput[prop],
+      })
+    }
+
+    return inputHolder
+  }
+}

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 = []
 
-  let index = -1
-  const len = list.length
-  const willReturn = []
-
-  while (++index < len){
-    if (index === len - 1){
-      willReturn.push(list[ index ])
-    } else {
-      willReturn.push(list[ index ], separator)
+    while (++index < len) {
+      if (index === len - 1) {
+        willReturn.push(list[index])
+      } else {
+        willReturn.push(list[index], separator)
+      }
     }
-  }
 
-  return willReturn
+    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/mapKeys.js

@@ -0,0 +1,11 @@
+export function mapKeys(fn) {
+  return obj => {
+		const willReturn = {}
+
+		Object.keys(obj).forEach(key => {
+			willReturn[fn(key, obj[key])] = obj[key]
+		})
+
+		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
+  }
+}