rambda 6.8.2 → 7.0.1

package/src/splitEvery.js

@@ -1,17 +1,19 @@
-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,5 +1,22 @@
-export function startsWith(target, str){
-  if (arguments.length === 1) return _str => startsWith(target, _str)
+import {equals} from './equals.js'
+import {_isArray} from './_internals/_isArray.js'
 
-  return str.startsWith(target)
+export function startsWith(target, iterable) {
+  if (arguments.length === 1)
+    return _iterable => startsWith(target, _iterable)
+
+  if (typeof iterable === 'string') {
+    return iterable.startsWith(target)
+  }
+  if (!_isArray(target)) return false
+
+  let correct = true
+  const filtered = target.filter((x, index) => {
+    if (!correct) return false
+    const result = equals(x, iterable[index])
+    if (!result) correct = false
+    return result
+  })
+
+  return filtered.length === target.length
 }

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,12 +1,14 @@
-import { concat } from './concat'
-import { filter } from './filter'
-import { includes } from './includes'
+import {concat} from './concat'
+import {filter} from './filter'
+import {includes} from './includes'
 
-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'
 
-export function tail(listOrString){
+export function tail(listOrString) {
   return drop(1, listOrString)
 }

package/src/take.js

@@ -1,12 +1,10 @@
 import baseSlice from './_internals/baseSlice'
 
-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'
 
-export function takeLast(howMany, listOrString){
+export function takeLast(howMany, listOrString) {
   if (arguments.length === 1)
     return _listOrString => takeLast(howMany, _listOrString)
 
@@ -13,7 +13,5 @@ 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'
 
-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'
 
-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)

package/src/test.js

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

package/src/times.js

@@ -1,9 +1,9 @@
-import { map } from './map'
-import { range } from './range'
+import {map} from './map'
+import {range} from './range'
 
-export function times(fn, howMany){
+export function times(fn, howMany) {
   if (arguments.length === 1) return _howMany => times(fn, _howMany)
-  if (!Number.isInteger(howMany) || howMany < 0){
+  if (!Number.isInteger(howMany) || howMany < 0) {
     throw new RangeError('n must be an integer')
   }
 

package/src/toLower.js

@@ -1,3 +1,3 @@
-export function toLower(str){
+export function toLower(str) {
   return str.toLowerCase()
 }

package/src/toPairs.js

@@ -1,3 +1,3 @@
-export function toPairs(obj){
+export function toPairs(obj) {
   return Object.entries(obj)
 }

package/src/toString.js

@@ -1,3 +1,3 @@
-export function toString(x){
+export function toString(x) {
   return x.toString()
 }

package/src/toUpper.js

@@ -1,3 +1,3 @@
-export function toUpper(str){
+export function toUpper(str) {
   return str.toUpperCase()
 }

package/src/transpose.js

@@ -1,9 +1,10 @@
-import { _isArray } from './_internals/_isArray'
+import {_isArray} from './_internals/_isArray'
 
-export function transpose(array){
+export function transpose(array) {
   return array.reduce((acc, el) => {
     el.forEach((nestedEl, i) =>
-      _isArray(acc[ i ]) ? acc[ i ].push(nestedEl) : acc.push([ nestedEl ]))
+      _isArray(acc[i]) ? acc[i].push(nestedEl) : acc.push([nestedEl])
+    )
 
     return acc
   }, [])

package/src/trim.js

@@ -1,3 +1,3 @@
-export function trim(str){
+export function trim(str) {
   return str.trim()
 }

package/src/tryCatch.js

@@ -1,15 +1,15 @@
-import { isFunction } from './isFunction'
+import {isFunction} from './isFunction'
 
-export function tryCatch(fn, fallback){
-  if (!isFunction(fn)){
-    throw new Error(`R.tryCatch | fn '${ fn }'`)
+export function tryCatch(fn, fallback) {
+  if (!isFunction(fn)) {
+    throw new Error(`R.tryCatch | fn '${fn}'`)
   }
   const passFallback = isFunction(fallback)
 
   return (...inputs) => {
     try {
       return fn(...inputs)
-    } catch (e){
+    } catch (e) {
       return passFallback ? fallback(e, ...inputs) : fallback
     }
   }

package/src/type.js

@@ -1,34 +1,12 @@
-import { _isArray } from './_internals/_isArray'
-
-export function type(input){
-  const typeOf = typeof input
-
-  if (input === null){
+export function type(input) {
+  if (input === null) {
     return 'Null'
-  } else if (input === undefined){
+  } else if (input === undefined) {
     return 'Undefined'
-  } else if (typeOf === 'boolean'){
-    return 'Boolean'
-  } else if (typeOf === 'number'){
-    return Number.isNaN(input) ? 'NaN' : 'Number'
-  } else if (typeOf === 'string'){
-    return 'String'
-  } else if (_isArray(input)){
-    return 'Array'
-  } else if (typeOf === 'symbol'){
-    return 'Symbol'
-  } else if (input instanceof RegExp){
-    return 'RegExp'
+  } else if (Number.isNaN(input)) {
+    return 'NaN'
   }
+  const typeResult = Object.prototype.toString.call(input).slice(8, -1)
 
-  const asStr = input && input.toString ? input.toString() : ''
-
-  if ([ 'true', 'false' ].includes(asStr)) return 'Boolean'
-  if (!Number.isNaN(Number(asStr))) return 'Number'
-  if (asStr.startsWith('async')) return 'Async'
-  if (asStr === '[object Promise]') return 'Promise'
-  if (typeOf === 'function') return 'Function'
-  if (input instanceof String) return 'String'
-
-  return 'Object'
+  return typeResult === 'AsyncFunction' ? 'Async' : typeResult
 }

package/src/unapply.js

@@ -0,0 +1,5 @@
+export function unapply(fn) {
+  return function (...args) {
+    return fn.call(this, args)
+  }
+}

package/src/union.js

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

package/src/uniq.js

@@ -1,16 +1,13 @@
-import { includes } from './includes'
+import {_Set} from './_internals/set'
 
-export function uniq(list){
-  let index = -1
+export function uniq(list) {
+  const set = new _Set()
   const willReturn = []
-
-  while (++index < list.length){
-    const value = list[ index ]
-
-    if (!includes(value, willReturn)){
-      willReturn.push(value)
+  list.forEach(item => {
+    if (set.checkUniqueness(item)) {
+      willReturn.push(item)
     }
-  }
+  })
 
   return willReturn
 }

package/src/uniqWith.js

@@ -1,17 +1,28 @@
-import { any } from './any'
+function includesWith(predicate, target, list) {
+  let willReturn = false
+  let index = -1
+
+  while (++index < list.length && !willReturn) {
+    const value = list[index]
+
+    if (predicate(target, value)) {
+      willReturn = true
+    }
+  }
+
+  return willReturn
+}
 
-export function uniqWith(predicate, list){
+export function uniqWith(predicate, list) {
   if (arguments.length === 1) return _list => uniqWith(predicate, _list)
 
   let index = -1
   const willReturn = []
 
-  while (++index < list.length){
-    const value = list[ index ]
-    const flag = any(x => predicate(value, x),
-      willReturn)
+  while (++index < list.length) {
+    const value = list[index]
 
-    if (!flag){
+    if (!includesWith(predicate, value, willReturn)) {
       willReturn.push(value)
     }
   }

package/src/unless.js

@@ -1,7 +1,7 @@
-export function unless(predicate, whenFalse){
-  if (arguments.length === 1){
+export function unless(predicate, whenFalse) {
+  if (arguments.length === 1) {
     return _whenFalse => unless(predicate, _whenFalse)
   }
 
-  return input => predicate(input) ? input : whenFalse(input)
+  return input => (predicate(input) ? input : whenFalse(input))
 }

package/src/update.js

@@ -1,13 +1,11 @@
-import { curry } from './curry'
+import {curry} from './curry'
+import {cloneList} from './_internals/cloneList'
 
-function updateFn(
-  index, newValue, list
-){
-  const arrClone = list.slice()
+function updateFn(index, newValue, list) {
+  const clone = cloneList(list)
+  if (index === -1) return clone.fill(newValue, index)
 
-  return arrClone.fill(
-    newValue, index, index + 1
-  )
+  return clone.fill(newValue, index, index + 1)
 }
 
 export const update = curry(updateFn)

package/src/values.js

@@ -1,6 +1,6 @@
-import { type } from './type'
+import {type} from './type'
 
-export function values(obj){
+export function values(obj) {
   if (type(obj) !== 'Object') return []
 
   return Object.values(obj)

package/src/view.js

@@ -1,9 +1,9 @@
 const Const = x => ({
   x,
-  map : fn => Const(x),
+  map: fn => Const(x),
 })
 
-export function view(lens, target){
+export function view(lens, target) {
   if (arguments.length === 1) return _target => view(lens, _target)
 
   return lens(Const)(target).x

package/src/when.js

@@ -1,8 +1,6 @@
-import { curry } from './curry'
+import {curry} from './curry'
 
-function whenFn(
-  predicate, whenTrueFn, input
-){
+function whenFn(predicate, whenTrueFn, input) {
   if (!predicate(input)) return input
 
   return whenTrueFn(input)

package/src/where.js

@@ -1,11 +1,11 @@
-export function where(conditions, input){
-  if (input === undefined){
+export function where(conditions, input) {
+  if (input === undefined) {
     return _input => where(conditions, _input)
   }
   let flag = true
-  for (const prop in conditions){
-    const result = conditions[ prop ](input[ prop ])
-    if (flag && result === false){
+  for (const prop in conditions) {
+    const result = conditions[prop](input[prop])
+    if (flag && result === false) {
       flag = false
     }
   }

package/src/whereEq.js

@@ -1,14 +1,16 @@
-import { equals } from './equals'
-import { filter } from './filter'
+import {equals} from './equals'
+import {filter} from './filter'
 
-export function whereEq(condition, input){
-  if (arguments.length === 1){
+export function whereEq(condition, input) {
+  if (arguments.length === 1) {
     return _input => whereEq(condition, _input)
   }
 
-  const result = filter((conditionValue, conditionProp) =>
-    equals(conditionValue, input[ conditionProp ]),
-  condition)
+  const result = filter(
+    (conditionValue, conditionProp) =>
+      equals(conditionValue, input[conditionProp]),
+    condition
+  )
 
   return Object.keys(result).length === Object.keys(condition).length
 }

package/src/without.js

@@ -1,14 +1,14 @@
-import { includesArray } from './includes'
-import { reduce } from './reduce'
+import {reduce} from './reduce'
+import {_indexOf} from './equals'
 
-export function without(matchAgainst, source){
-  if (source === undefined){
+export function without(matchAgainst, source) {
+  if (source === undefined) {
     return _source => without(matchAgainst, _source)
   }
 
   return reduce(
     (prev, current) =>
-    includesArray(current, matchAgainst) ? prev : prev.concat(current),
+      _indexOf(current, matchAgainst) > -1 ? prev : prev.concat(current),
     [],
     source
   )

package/src/xor.js

@@ -1,5 +1,5 @@
-export function xor(a, b){
+export function xor(a, b) {
   if (arguments.length === 1) return _b => xor(a, _b)
 
-  return Boolean(a) && !b || Boolean(b) && !a
+  return (Boolean(a) && !b) || (Boolean(b) && !a)
 }

package/src/zip.js

@@ -1,11 +1,11 @@
-export function zip(left, right){
+export function zip(left, right) {
   if (arguments.length === 1) return _right => zip(left, _right)
 
   const result = []
   const length = Math.min(left.length, right.length)
 
-  for (let i = 0; i < length; i++){
-    result[ i ] = [ left[ i ], right[ i ] ]
+  for (let i = 0; i < length; i++) {
+    result[i] = [left[i], right[i]]
   }
 
   return result

package/src/zipObj.js

@@ -1,12 +1,10 @@
-import { take } from './take'
+import {take} from './take'
 
-export function zipObj(keys, values){
+export function zipObj(keys, values) {
   if (arguments.length === 1) return yHolder => zipObj(keys, yHolder)
 
-  return take(values.length, keys).reduce((
-    prev, xInstance, i
-  ) => {
-    prev[ xInstance ] = values[ i ]
+  return take(values.length, keys).reduce((prev, xInstance, i) => {
+    prev[xInstance] = values[i]
 
     return prev
   }, {})

package/src/zipWith.js

@@ -1,11 +1,10 @@
-import { curry } from './curry'
-import { take } from './take'
+import {curry} from './curry'
+import {take} from './take'
 
-function zipWithFn(
-  fn, x, y
-){
-  return take(x.length > y.length ? y.length : x.length,
-    x).map((xInstance, i) => fn(xInstance, y[ i ]))
+function zipWithFn(fn, x, y) {
+  return take(x.length > y.length ? y.length : x.length, x).map(
+    (xInstance, i) => fn(xInstance, y[i])
+  )
 }
 
 export const zipWith = curry(zipWithFn)