• __
• addIndex
• ap
• aperture
• applyTo
• ascend
• binary
• call
• comparator
• composeK
• composeP
• composeWith
• construct
• constructN
• contains
• countBy
• descend
• differenceWith
• dissocPath
• empty
• eqBy
• forEachObjIndexed
• gt
• gte
• hasIn
• innerJoin
• insert
• insertAll
• into
• invert
• invertObj
• invoker
• juxt
• keysIn
• lift
• liftN
• lt
• lte
• mapAccum
• mapAccumRight
• memoizeWith
• mergeDeepLeft
• mergeDeepWith
• mergeDeepWithKey
• mergeRight
• mergeWith
• mergeWithKey
• nAry
• nthArg
• o
• otherwise
• pair
• partialRight
• pathSatisfies
• pickBy
• pipeK
• pipeP
• pipeWith
• project
• propSatisfies
• reduceBy
• reduceRight
• reduceWhile
• reduced
• remove
• scan
• sequence
• sortWith
• symmetricDifferenceWith
• andThen
• toPairsIn
• transduce
• traverse
• unary
• uncurryN
• unfold
• unionWith
• uniqBy
• unnest
• until
• useWith
• valuesIn
• xprod
• thunkify
• default

export function add(a, b) {
  if (arguments.length === 1) return _b => add(a, _b)

  return Number(a) + Number(b)
}

import {add} from './add'
import {add as addRamda} from 'ramda'
import {compareCombinations} from './_internals/testUtils'

test('with number', () => {
  expect(add(2, 3)).toEqual(5)
  expect(add(7)(10)).toEqual(17)
})

test('string is bad input', () => {
  expect(add('foo', 'bar')).toBeNaN()
})

test('ramda specs', () => {
  expect(add('1', '2')).toEqual(3)
  expect(add(1, '2')).toEqual(3)
  expect(add(true, false)).toEqual(1)
  expect(add(null, null)).toEqual(0)
  expect(add(undefined, undefined)).toEqual(NaN)
  expect(add(new Date(1), new Date(2))).toEqual(3)
})

const possibleInputs = [
  /foo/,
  'foo',
  true,
  3,
  NaN,
  4,
  [],
  Promise.resolve(1),
]

describe('brute force', () => {
  compareCombinations({
    fn: add,
    fnRamda: addRamda,
    firstInput: possibleInputs,
    secondInput: possibleInputs,
    callback: errorsCounters => {
      expect(errorsCounters).toMatchInlineSnapshot(`
        Object {
          "ERRORS_MESSAGE_MISMATCH": 0,
          "ERRORS_TYPE_MISMATCH": 0,
          "RESULTS_MISMATCH": 0,
          "SHOULD_NOT_THROW": 0,
          "SHOULD_THROW": 0,
          "TOTAL_TESTS": 64,
        }
      `)
    },
  })
})

import {curry} from './curry'
import {cloneList} from './_internals/cloneList'

function adjustFn(index, replaceFn, 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
}

export const adjust = curry(adjustFn)

import {add} from './add'
import {adjust} from './adjust'
import {pipe} from './pipe'

const list = [0, 1, 2]
const expected = [0, 11, 2]

test('happy', () => {})

test('happy', () => {
  expect(adjust(1, add(10), list)).toEqual(expected)
})

test('with curring type 1 1 1', () => {
  expect(adjust(1)(add(10))(list)).toEqual(expected)
})

test('with curring type 1 2', () => {
  expect(adjust(1)(add(10), list)).toEqual(expected)
})

test('with curring type 2 1', () => {
  expect(adjust(1, add(10))(list)).toEqual(expected)
})

test('with negative index', () => {
  expect(adjust(-2, add(10), list)).toEqual(expected)
})

test('when index is out of bounds', () => {
  const list = [0, 1, 2, 3]
  expect(adjust(4, add(1), list)).toEqual(list)
  expect(adjust(-5, add(1), list)).toEqual(list)
})

export function all(predicate, list) {
  if (arguments.length === 1) return _list => all(predicate, _list)

  for (let i = 0; i < list.length; i++) {
    if (!predicate(list[i])) return false
  }

  return true
}

import {all} from './all'

const list = [0, 1, 2, 3, 4]

test('when true', () => {
  const fn = x => x > -1

  expect(all(fn)(list)).toBeTrue()
})

test('when false', () => {
  const fn = x => x > 2

  expect(all(fn, list)).toBeFalse()
})

import {isTruthy} from './_internals/isTruthy'
import {type} from './type'

export function allFalse(...inputs) {
  let counter = 0
  while (counter < inputs.length) {
    const x = inputs[counter]

    if (type(x) === 'Function') {
      if (isTruthy(x())) {
        return false
      }
    } else if (isTruthy(x)) {
      return false
    }

    counter++
  }

  return true
}

import {runTests} from 'helpers-fn'

import {allFalse} from './allFalse'

const happy = {ok: [() => false, () => [], () => {}, null, false, []]}
const withArray = {fail: [...happy.ok, [1]]}
const withObject = {fail: [...happy.ok, {a: 1}]}
const withFunction = {fail: [...happy.ok, () => ({a: 1})]}
const withBoolean = {fail: [...happy.ok, true]}

const testData = {
  label: 'R.allFalse',
  data: [happy, withArray, withObject, withFunction, withBoolean],
  fn: input => allFalse(...input),
}
runTests(testData)

export function allPass(predicates) {
  return (...input) => {
    let counter = 0
    while (counter < predicates.length) {
      if (!predicates[counter](...input)) {
        return false
      }
      counter++
    }

    return true
  }
}

import {allPass} from './allPass'

test('happy', () => {
  const rules = [x => typeof x === 'number', x => x > 10, x => x * 7 < 100]

  expect(allPass(rules)(11)).toBeTrue()

  expect(allPass(rules)(undefined)).toBeFalse()
})

test('when returns true', () => {
  const conditionArr = [val => val.a === 1, val => val.b === 2]

  expect(
    allPass(conditionArr)({
      a: 1,
      b: 2,
    })
  ).toBeTrue()
})

test('when returns false', () => {
  const conditionArr = [val => val.a === 1, val => val.b === 3]

  expect(
    allPass(conditionArr)({
      a: 1,
      b: 2,
    })
  ).toBeFalse()
})

test('works with multiple inputs', () => {
  var fn = function (w, x, y, z) {
    return w + x === y + z
  }
  expect(allPass([fn])(3, 3, 3, 3)).toBeTrue()
})

import {isFalsy} from './_internals/isFalsy'
import {type} from './type'

export function allTrue(...inputs) {
  let counter = 0
  while (counter < inputs.length) {
    const x = inputs[counter]

    if (type(x) === 'Function') {
      if (isFalsy(x())) {
        return false
      }
    } else if (isFalsy(x)) {
      return false
    }

    counter++
  }

  return true
}

import {allTrue} from './allTrue'

test('with functions', () => {
  const foo = () => 1
  const bar = () => false
  const baz = () => JSON.parse('{sda')
  const result = allTrue(foo, bar, baz)
  expect(result).toBeFalse()
})

test('usage with non boolean', () => {
  const foo = {a: 1}
  const baz = [1, 2, 3]

  const result = allTrue(foo, foo, baz)
  expect(result).toBeTrue()
})

test('usage with boolean', () => {
  const foo = 4
  const baz = [1, 2, 3]

  const result = allTrue(foo > 2, baz.length === 3)
  expect(result).toBeTrue()
})

test('escapes early - case 0', () => {
  const foo = undefined
  const result = allTrue(foo, () => foo.a)
  expect(result).toBeFalse()
})

test('escapes early - case 1', () => {
  const foo = null
  const result = allTrue(foo, () => foo.a)
  expect(result).toBeFalse()
})

test('escapes early - case 2', () => {
  const foo = {a: 'bar'}
  const result = allTrue(foo, foo.a, foo.a.b)
  expect(result).toBeFalse()
})

test('escapes early - case 3', () => {
  const foo = {a: {b: 'foo'}}
  const result = allTrue(
    foo,
    () => foo.a,
    () => foo.a.b
  )
  expect(result).toBeTrue()
})

import {type} from './type'

export function allType(targetType) {
  return (...inputs) => {
    let counter = 0

    while (counter < inputs.length) {
      if (type(inputs[counter]) !== targetType) {
        return false
      }
      counter++
    }

    return true
  }
}

import {allType} from './allType'

test('when true', () => {
  const result = allType('Array')([1, 2, 3], [], [null])

  expect(result).toBeTrue()
})

test('when false', () => {
  const result = allType('String')(1, undefined, null, [])

  expect(result).toBeFalse()
})

export function always(x) {
  return () => x
}

import {always} from './always'
import {F} from './F'

test('happy', () => {
  const fn = always(7)

  expect(fn()).toEqual(7)
  expect(fn()).toEqual(7)
})

test('f', () => {
  const fn = always(F())

  expect(fn()).toBeFalse()
  expect(fn()).toBeFalse()
})

export function any(predicate, list) {
  if (arguments.length === 1) return _list => any(predicate, _list)

  let counter = 0
  while (counter < list.length) {
    if (predicate(list[counter], counter)) {
      return true
    }
    counter++
  }

  return false
}

import {any} from './any'

const list = [1, 2, 3]

test('happy', () => {
  expect(any(x => x < 0, list)).toBeFalse()
})

test('with curry', () => {
  expect(any(x => x > 2)(list)).toBeTrue()
})

import {isFalsy} from './_internals/isFalsy'
import {type} from './type'

export function anyFalse(...inputs) {
  let counter = 0
  while (counter < inputs.length) {
    const x = inputs[counter]

    if (type(x) === 'Function') {
      if (isFalsy(x())) {
        return true
      }
    } else if (isFalsy(x)) {
      return true
    }

    counter++
  }

  return false
}

import {anyFalse} from './anyFalse'

test('when true', () => {
  expect(anyFalse(true, true, false)).toBeTruthy()
})

test('when false', () => {
  expect(anyFalse(true, true)).toBeFalsy()
})

test('supports function', () => {
  expect(
    anyFalse(
      true,
      () => true,
      () => false
    )
  ).toBeTruthy()
})

export function anyPass(predicates) {
  return (...input) => {
    let counter = 0
    while (counter < predicates.length) {
      if (predicates[counter](...input)) {
        return true
      }
      counter++
    }

    return false
  }
}

import {anyPass} from './anyPass'

test('happy', () => {
  const rules = [x => typeof x === 'string', x => x > 10]
  const predicate = anyPass(rules)
  expect(predicate('foo')).toBeTrue()
  expect(predicate(6)).toBeFalse()
})

test('happy', () => {
  const rules = [x => typeof x === 'string', x => x > 10]

  expect(anyPass(rules)(11)).toBeTrue()

  expect(anyPass(rules)(undefined)).toBeFalse()
})

const obj = {
  a: 1,
  b: 2,
}

test('when returns true', () => {
  const conditionArr = [val => val.a === 1, val => val.a === 2]

  expect(anyPass(conditionArr)(obj)).toBeTrue()
})

test('when returns false + curry', () => {
  const conditionArr = [val => val.a === 2, val => val.b === 3]

  expect(anyPass(conditionArr)(obj)).toBeFalse()
})

test('with empty predicates list', () => {
  expect(anyPass([])(3)).toEqual(false)
})

test('works with multiple inputs', () => {
  var fn = function (w, x, y, z) {
    console.log(w, x, y, z)
    return w + x === y + z
  }
  expect(anyPass([fn])(3, 3, 3, 3)).toBeTrue()
})

import {isTruthy} from './_internals/isTruthy'
import {type} from './type'

export function anyTrue(...inputs) {
  let counter = 0
  while (counter < inputs.length) {
    const x = inputs[counter]

    if (type(x) === 'Function') {
      if (isTruthy(x())) {
        return true
      }
    } else if (isTruthy(x)) {
      return true
    }

    counter++
  }

  return false
}

import {anyTrue} from './anyTrue'

test('when true', () => {
  expect(anyTrue(true, true, false)).toBeTruthy()
})

test('when false', () => {
  expect(anyTrue(false, false, false)).toBeFalsy()
})

test('supports function', () => {
  expect(
    anyTrue(
      false,
      false,
      false,
      () => false,
      () => true
    )
  ).toBeTruthy()
})

import {type} from './type'

export function anyType(targetType) {
  return (...inputs) => {
    let counter = 0

    while (counter < inputs.length) {
      if (type(inputs[counter]) === targetType) {
        return true
      }
      counter++
    }

    return false
  }
}

import {anyType} from './anyType'

test('when true', () => {
  const result = anyType('Array')(1, undefined, null, [])

  expect(result).toBeTrue()
})

test('when false', () => {
  const result = anyType('String')(1, undefined, null, [])

  expect(result).toBeFalse()
})

import {cloneList} from './_internals/cloneList'

export function append(x, input) {
  if (arguments.length === 1) return _input => append(x, _input)

  if (typeof input === 'string') return input.split('').concat(x)

  const clone = cloneList(input)
  clone.push(x)

  return clone
}

import {append} from './append'

test('happy', () => {
  expect(append('tests', ['write', 'more'])).toEqual([
    'write',
    'more',
    'tests',
  ])
})

test('append to empty array', () => {
  expect(append('tests')([])).toEqual(['tests'])
})

test('with strings', () => {
  expect(append('o', 'fo')).toEqual(['f', 'o', 'o'])
})

export function apply(fn, args) {
  if (arguments.length === 1) {
    return _args => apply(fn, _args)
  }

  return fn.apply(this, args)
}

import {apply} from './apply'
import {bind} from './bind'
import {identity} from './identity'

test('happy', () => {
  expect(apply(identity, [1, 2, 3])).toEqual(1)
})

test('applies function to argument list', function () {
  expect(apply(Math.max, [1, 2, 3, -99, 42, 6, 7])).toEqual(42)
})

test('provides no way to specify context', function () {
  const obj = {
    method: function () {
      return this === obj
    },
  }
  expect(apply(obj.method, [])).toEqual(false)
  expect(apply(bind(obj.method, obj), [])).toEqual(true)
})

import {assocPath} from './assocPath'
import {path as pathModule} from './path'
const ALLOWED_OPERATIONS = ['remove', 'add', 'update']

export function removeAtPath(path, obj) {
  const p = typeof path === 'string' ? path.split('.') : path

  const len = p.length
  if (len === 0) return
  if (len === 1) return delete obj[p[0]]
  if (len === 2) return delete obj[p[0]][p[1]]
  if (len === 3) return delete obj[p[0]][p[1]][p[2]]
  if (len === 4) return delete obj[p[0]][p[1]][p[2]][p[3]]
  if (len === 5) return delete obj[p[0]][p[1]][p[2]][p[3]][p[4]]
  if (len === 6) {
    return delete obj[p[0]][p[1]][p[2]][p[3]][p[4]][p[5]]
  }
  if (len === 7) {
    return delete obj[p[0]][p[1]][p[2]][p[3]][p[4]][p[5]][p[6]]
  }
  if (len === 8) {
    return delete obj[p[0]][p[1]][p[2]][p[3]][p[4]][p[5]][p[6]][p[7]]
  }
  if (len === 9) {
    return delete obj[p[0]][p[1]][p[2]][p[3]][p[4]][p[5]][p[6]][p[7]][p[8]]
  }
  if (len === 10) {
    return delete obj[p[0]][p[1]][p[2]][p[3]][p[4]][p[5]][p[6]][p[7]][p[8]][
      p[9]
    ]
  }
}

export function applyDiff(rules, obj) {
  if (arguments.length === 1) return _obj => applyDiff(rules, _obj)

  let clone = {...obj}

  rules.forEach(({op, path, value}) => {
    if (!ALLOWED_OPERATIONS.includes(op)) return
    if (op === 'add' && path && value !== undefined) {
      if (pathModule(path, obj)) return

      return (clone = assocPath(path, value, clone))
    }

    if (op === 'remove') {
      if (pathModule(path, obj) === undefined) return

      return removeAtPath(path, clone)
    }
    if (op === 'update' && path && value !== undefined) {
      if (pathModule(path, obj) === undefined) return

      return (clone = assocPath(path, value, clone))
    }
  })

  return clone
}

import {applyDiff} from './applyDiff'

test('remove operation', () => {
  const rules = [
    {
      op: 'remove',
      path: 'a.b',
    },
  ]
  const result = applyDiff(rules, {
    a: {
      b: 1,
      c: 2,
    },
  })
  expect(result).toEqual({a: {c: 2}})
})

test('update operation', () => {
  const rules = [
    {
      op: 'update',
      path: 'a.b',
      value: 3,
    },
    {
      op: 'update',
      path: 'a.c.1',
      value: 3,
    },
    {
      op: 'update',
      path: 'a.d',
      value: 3,
    },
  ]
  const result = applyDiff(rules, {
    a: {
      b: 1,
      c: [1, 2],
    },
  })
  expect(result).toEqual({
    a: {
      b: 3,
      c: [1, 3],
    },
  })
})

test('add operation', () => {
  const rules = [
    {
      op: 'add',
      path: 'a.b',
      value: 3,
    },
    {
      op: 'add',
      path: 'a.d',
      value: 3,
    },
  ]
  const result = applyDiff(rules, {
    a: {
      b: 1,
      c: 2,
    },
  })

  expect(result).toEqual({
    a: {
      b: 1,
      c: 2,
      d: 3,
    },
  })
})

import {_isArray} from './_internals/_isArray'

// recursively traverse the given spec object to find the highest arity function
function __findHighestArity(spec, max = 0) {
  for (const key in spec) {
    if (spec.hasOwnProperty(key) === false || key === 'constructor') continue

    if (typeof spec[key] === 'object') {
      max = Math.max(max, __findHighestArity(spec[key]))
    }

    if (typeof spec[key] === 'function') {
      max = Math.max(max, spec[key].length)
    }
  }

  return max
}

function __filterUndefined() {
  const defined = []
  let i = 0
  const l = arguments.length
  while (i < l) {
    if (typeof arguments[i] === 'undefined') break
    defined[i] = arguments[i]
    i++
  }

  return defined
}

function __applySpecWithArity(spec, arity, cache) {
  const remaining = arity - cache.length

  if (remaining === 1)
    return x =>
      __applySpecWithArity(spec, arity, __filterUndefined(...cache, x))
  if (remaining === 2)
    return (x, y) =>
      __applySpecWithArity(spec, arity, __filterUndefined(...cache, x, y))
  if (remaining === 3)
    return (x, y, z) =>
      __applySpecWithArity(spec, arity, __filterUndefined(...cache, x, y, z))
  if (remaining === 4)
    return (x, y, z, a) =>
      __applySpecWithArity(
        spec,
        arity,
        __filterUndefined(...cache, x, y, z, a)
      )
  if (remaining > 4)
    return (...args) =>
      __applySpecWithArity(spec, arity, __filterUndefined(...cache, ...args))

  // handle spec as Array
  if (_isArray(spec)) {
    const ret = []
    let i = 0
    const l = spec.length
    for (; i < l; i++) {
      // handle recursive spec inside array
      if (typeof spec[i] === 'object' || _isArray(spec[i])) {
        ret[i] = __applySpecWithArity(spec[i], arity, cache)
      }
      // apply spec to the key
      if (typeof spec[i] === 'function') {
        ret[i] = spec[i](...cache)
      }
    }

    return ret
  }

  // handle spec as Object
  const ret = {}
  // apply callbacks to each property in the spec object
  for (const key in spec) {
    if (spec.hasOwnProperty(key) === false || key === 'constructor') continue

    // apply the spec recursively
    if (typeof spec[key] === 'object') {
      ret[key] = __applySpecWithArity(spec[key], arity, cache)
      continue
    }

    // apply spec to the key
    if (typeof spec[key] === 'function') {
      ret[key] = spec[key](...cache)
    }
  }

  return ret
}

export function applySpec(spec, ...args) {
  // get the highest arity spec function, cache the result and pass to __applySpecWithArity
  const arity = __findHighestArity(spec)

  if (arity === 0) {
    return () => ({})
  }
  const toReturn = __applySpecWithArity(spec, arity, args)

  return toReturn
}

import {applySpec as applySpecRamda, nAry} from 'ramda'
import {add, always, compose, dec, inc, map, path, prop, T} from '../rambda'
import {applySpec} from './applySpec'

test('different than Ramda when bad spec', () => {
  const result = applySpec({sum: {a: 1}})(1, 2)
  const ramdaResult = applySpecRamda({sum: {a: 1}})(1, 2)
  expect(result).toEqual({})
  expect(ramdaResult).toEqual({sum: {a: {}}})
})

test('works with empty spec', () => {
  expect(applySpec({})()).toEqual({})
  expect(applySpec([])(1, 2)).toEqual({})
  expect(applySpec(null)(1, 2)).toEqual({})
})

test('works with unary functions', () => {
  const result = applySpec({
    v: inc,
    u: dec,
  })(1)
  const expected = {
    v: 2,
    u: 0,
  }
  expect(result).toEqual(expected)
})

test('works with binary functions', () => {
  const result = applySpec({sum: add})(1, 2)
  expect(result).toEqual({sum: 3})
})

test('works with nested specs', () => {
  const result = applySpec({
    unnested: always(0),
    nested: {sum: add},
  })(1, 2)
  const expected = {
    unnested: 0,
    nested: {sum: 3},
  }
  expect(result).toEqual(expected)
})

test('works with arrays of nested specs', () => {
  const result = applySpec({
    unnested: always(0),
    nested: [{sum: add}],
  })(1, 2)

  expect(result).toEqual({
    unnested: 0,
    nested: [{sum: 3}],
  })
})

test('works with arrays of spec objects', () => {
  const result = applySpec([{sum: add}])(1, 2)

  expect(result).toEqual([{sum: 3}])
})

test('works with arrays of functions', () => {
  const result = applySpec([map(prop('a')), map(prop('b'))])([
    {
      a: 'a1',
      b: 'b1',
    },
    {
      a: 'a2',
      b: 'b2',
    },
  ])
  const expected = [
    ['a1', 'a2'],
    ['b1', 'b2'],
  ]
  expect(result).toEqual(expected)
})

test('works with a spec defining a map key', () => {
  expect(applySpec({map: prop('a')})({a: 1})).toEqual({map: 1})
})

test('cannot retains the highest arity', () => {
  const f = applySpec({
    f1: nAry(2, T),
    f2: nAry(5, T),
  })
  const fRamda = applySpecRamda({
    f1: nAry(2, T),
    f2: nAry(5, T),
  })
  expect(f.length).toBe(0)
  expect(fRamda.length).toBe(5)
})

test('returns a curried function', () => {
  expect(applySpec({sum: add})(1)(2)).toEqual({sum: 3})
})

// Additional tests
// ============================================
test('arity', () => {
  const spec = {
    one: x1 => x1,
    two: (x1, x2) => x1 + x2,
    three: (x1, x2, x3) => x1 + x2 + x3,
  }
  expect(applySpec(spec, 1, 2, 3)).toEqual({
    one: 1,
    two: 3,
    three: 6,
  })
})

test('arity over 5 arguments', () => {
  const spec = {
    one: x1 => x1,
    two: (x1, x2) => x1 + x2,
    three: (x1, x2, x3) => x1 + x2 + x3,
    four: (x1, x2, x3, x4) => x1 + x2 + x3 + x4,
    five: (x1, x2, x3, x4, x5) => x1 + x2 + x3 + x4 + x5,
  }
  expect(applySpec(spec, 1, 2, 3, 4, 5)).toEqual({
    one: 1,
    two: 3,
    three: 6,
    four: 10,
    five: 15,
  })
})

test('curried', () => {
  const spec = {
    one: x1 => x1,
    two: (x1, x2) => x1 + x2,
    three: (x1, x2, x3) => x1 + x2 + x3,
  }
  expect(applySpec(spec)(1)(2)(3)).toEqual({
    one: 1,
    two: 3,
    three: 6,
  })
})

test('curried over 5 arguments', () => {
  const spec = {
    one: x1 => x1,
    two: (x1, x2) => x1 + x2,
    three: (x1, x2, x3) => x1 + x2 + x3,
    four: (x1, x2, x3, x4) => x1 + x2 + x3 + x4,
    five: (x1, x2, x3, x4, x5) => x1 + x2 + x3 + x4 + x5,
  }
  expect(applySpec(spec)(1)(2)(3)(4)(5)).toEqual({
    one: 1,
    two: 3,
    three: 6,
    four: 10,
    five: 15,
  })
})

test('undefined property', () => {
  const spec = {prop: path(['property', 'doesnt', 'exist'])}
  expect(applySpec(spec, {})).toEqual({prop: undefined})
})

test('restructure json object', () => {
  const spec = {
    id: path('user.id'),
    name: path('user.firstname'),
    profile: path('user.profile'),
    doesntExist: path('user.profile.doesntExist'),
    info: {views: compose(inc, prop('views'))},
    type: always('playa'),
  }

  const data = {
    user: {
      id: 1337,
      firstname: 'john',
      lastname: 'shaft',
      profile: 'shaft69',
    },
    views: 42,
  }

  expect(applySpec(spec, data)).toEqual({
    id: 1337,
    name: 'john',
    profile: 'shaft69',
    doesntExist: undefined,
    info: {views: 43},
    type: 'playa',
  })
})

import {curry} from './curry'

function assocFn(prop, newValue, obj) {
  return Object.assign({}, obj, {[prop]: newValue})
}

export const assoc = curry(assocFn)

import {assoc} from './assoc'

test('adds a key to an empty object', () => {
  expect(assoc('a', 1, {})).toEqual({a: 1})
})

test('adds a key to a non-empty object', () => {
  expect(assoc('b', 2, {a: 1})).toEqual({
    a: 1,
    b: 2,
  })
})

test('adds a key to a non-empty object - curry case 1', () => {
  expect(assoc('b', 2)({a: 1})).toEqual({
    a: 1,
    b: 2,
  })
})

test('adds a key to a non-empty object - curry case 2', () => {
  expect(assoc('b')(2, {a: 1})).toEqual({
    a: 1,
    b: 2,
  })
})

test('adds a key to a non-empty object - curry case 3', () => {
  const result = assoc('b')(2)({a: 1})

  expect(result).toEqual({
    a: 1,
    b: 2,
  })
})

test('changes an existing key', () => {
  expect(assoc('a', 2, {a: 1})).toEqual({a: 2})
})

test('undefined is considered an empty object', () => {
  expect(assoc('a', 1, undefined)).toEqual({a: 1})
})

test('null is considered an empty object', () => {
  expect(assoc('a', 1, null)).toEqual({a: 1})
})

test('value can be null', () => {
  expect(assoc('a', null, null)).toEqual({a: null})
})

test('value can be undefined', () => {
  expect(assoc('a', undefined, null)).toEqual({a: undefined})
})

test('assignment is shallow', () => {
  expect(assoc('a', {b: 2}, {a: {c: 3}})).toEqual({a: {b: 2}})
})

import {_isArray} from './_internals/_isArray'
import {_isInteger} from './_internals/_isInteger'
import {assoc} from './assoc'
import {curry} from './curry'
import {cloneList} from './_internals/cloneList'

function assocPathFn(path, newValue, input) {
  const pathArrValue =
    typeof path === 'string'
      ? path.split('.').map(x => (_isInteger(Number(x)) ? Number(x) : x))
      : path
  if (pathArrValue.length === 0) {
    return newValue
  }

  const index = pathArrValue[0]
  if (pathArrValue.length > 1) {
    const condition =
      typeof input !== 'object' ||
      input === null ||
      !input.hasOwnProperty(index)

    const nextinput = condition
      ? _isInteger(pathArrValue[1])
        ? []
        : {}
      : input[index]

    newValue = assocPathFn(
      Array.prototype.slice.call(pathArrValue, 1),
      newValue,
      nextinput
    )
  }

  if (_isInteger(index) && _isArray(input)) {
    const arr = cloneList(input)
    arr[index] = newValue

    return arr
  }

  return assoc(index, newValue, input)
}

export const assocPath = curry(assocPathFn)

import {assocPath} from './assocPath'

test('string can be used as path input', () => {
  const testObj = {
    a: [{b: 1}, {b: 2}],
    d: 3,
  }
  const result = assocPath('a.0.b', 10, testObj)
  const expected = {
    a: [{b: 10}, {b: 2}],
    d: 3,
  }
  expect(result).toEqual(expected)
})

test('bug', () => {
  /*
    https://github.com/selfrefactor/rambda/issues/524
  */
  const state = {}

  const withDateLike = assocPath(
    ['outerProp', '2020-03-10'],
    {prop: 2},
    state
  )
  const withNumber = assocPath(['outerProp', '5'], {prop: 2}, state)

  const withDateLikeExpected = {outerProp: {'2020-03-10': {prop: 2}}}
  const withNumberExpected = {outerProp: {5: {prop: 2}}}
  expect(withDateLike).toEqual(withDateLikeExpected)
  expect(withNumber).toEqual(withNumberExpected)
})

test('adds a key to an empty object', () => {
  expect(assocPath(['a'], 1, {})).toEqual({a: 1})
})

test('adds a key to a non-empty object', () => {
  expect(assocPath('b', 2, {a: 1})).toEqual({
    a: 1,
    b: 2,
  })
})

test('adds a nested key to a non-empty object', () => {
  expect(assocPath('b.c', 2, {a: 1})).toEqual({
    a: 1,
    b: {c: 2},
  })
})

test('adds a nested key to a nested non-empty object - curry case 1', () => {
  expect(
    assocPath(
      'b.d',
      3
    )({
      a: 1,
      b: {c: 2},
    })
  ).toEqual({
    a: 1,
    b: {
      c: 2,
      d: 3,
    },
  })
})

test('adds a key to a non-empty object - curry case 1', () => {
  expect(assocPath('b', 2)({a: 1})).toEqual({
    a: 1,
    b: 2,
  })
})

test('adds a nested key to a non-empty object - curry case 1', () => {
  expect(assocPath('b.c', 2)({a: 1})).toEqual({
    a: 1,
    b: {c: 2},
  })
})

test('adds a key to a non-empty object - curry case 2', () => {
  expect(assocPath('b')(2, {a: 1})).toEqual({
    a: 1,
    b: 2,
  })
})

test('adds a key to a non-empty object - curry case 3', () => {
  const result = assocPath('b')(2)({a: 1})

  expect(result).toEqual({
    a: 1,
    b: 2,
  })
})

test('changes an existing key', () => {
  expect(assocPath('a', 2, {a: 1})).toEqual({a: 2})
})

test('undefined is considered an empty object', () => {
  expect(assocPath('a', 1, undefined)).toEqual({a: 1})
})

test('null is considered an empty object', () => {
  expect(assocPath('a', 1, null)).toEqual({a: 1})
})

test('value can be null', () => {
  expect(assocPath('a', null, null)).toEqual({a: null})
})

test('value can be undefined', () => {
  expect(assocPath('a', undefined, null)).toEqual({a: undefined})
})

test('assignment is shallow', () => {
  expect(assocPath('a', {b: 2}, {a: {c: 3}})).toEqual({a: {b: 2}})
})

test('empty array as path', () => {
  const result = assocPath([], 3, {
    a: 1,
    b: 2,
  })
  expect(result).toEqual(3)
})

test('happy', () => {
  const expected = {foo: {bar: {baz: 42}}}
  const result = assocPath(['foo', 'bar', 'baz'], 42, {foo: null})
  expect(result).toEqual(expected)
})

import {curryN} from './curryN'

export function bind(fn, thisObj) {
  if (arguments.length === 1) {
    return _thisObj => bind(fn, _thisObj)
  }

  return curryN(fn.length, (...args) => fn.apply(thisObj, args))
}

import {bind} from './bind'

function Foo(x) {
  this.x = x
}
function add(x) {
  return this.x + x
}
function Bar(x, y) {
  this.x = x
  this.y = y
}
Bar.prototype = new Foo()
Bar.prototype.getX = function () {
  return 'prototype getX'
}

test('returns a function', function () {
  expect(typeof bind(add)(Foo)).toEqual('function')
})

test('returns a function bound to the specified context object', function () {
  const f = new Foo(12)
  function isFoo() {
    return this instanceof Foo
  }
  const isFooBound = bind(isFoo, f)
  expect(isFoo()).toEqual(false)
  expect(isFooBound()).toEqual(true)
})

test('works with built-in types', function () {
  const abc = bind(String.prototype.toLowerCase, 'ABCDEFG')
  expect(typeof abc).toEqual('function')
  expect(abc()).toEqual('abcdefg')
})

test('works with user-defined types', function () {
  const f = new Foo(12)
  function getX() {
    return this.x
  }
  const getXFooBound = bind(getX, f)
  expect(getXFooBound()).toEqual(12)
})

test('works with plain objects', function () {
  const pojso = {
    x: 100,
  }
  function incThis() {
    return this.x + 1
  }
  const incPojso = bind(incThis, pojso)
  expect(typeof incPojso).toEqual('function')
  expect(incPojso()).toEqual(101)
})

test('does not interfere with existing object methods', function () {
  const b = new Bar('a', 'b')
  function getX() {
    return this.x
  }
  const getXBarBound = bind(getX, b)
  expect(b.getX()).toEqual('prototype getX')
  expect(getXBarBound()).toEqual('a')
})

test('preserves arity', function () {
  const f0 = function () {
    return 0
  }
  const f1 = function (a) {
    return a
  }
  const f2 = function (a, b) {
    return a + b
  }
  const f3 = function (a, b, c) {
    return a + b + c
  }

  expect(bind(f0, {}).length).toEqual(0)
  expect(bind(f1, {}).length).toEqual(1)
  expect(bind(f2, {}).length).toEqual(2)
  expect(bind(f3, {}).length).toEqual(3)
})

export function both(f, g) {
  if (arguments.length === 1) return _g => both(f, _g)

  return (...input) => f(...input) && g(...input)
}

import {both} from './both'

const firstFn = val => val > 0
const secondFn = val => val < 10

test('with curry', () => {
  expect(both(firstFn)(secondFn)(17)).toBeFalse()
})

test('without curry', () => {
  expect(both(firstFn, secondFn)(7)).toBeTrue()
})

test('with multiple inputs', () => {
  const between = function (a, b, c) {
    return a < b && b < c
  }
  const total20 = function (a, b, c) {
    return a + b + c === 20
  }
  const fn = both(between, total20)
  expect(fn(5, 7, 8)).toBeTrue()
})

test('skip evaluation of the second expression', () => {
  let effect = 'not evaluated'
  const F = function () {
    return false
  }
  const Z = function () {
    effect = 'Z got evaluated'
  }
  both(F, Z)()

  expect(effect).toBe('not evaluated')
})

export function chain(fn, list) {
  if (arguments.length === 1) {
    return _list => chain(fn, _list)
  }

  return [].concat(...list.map(fn))
}

import {chain} from './chain'
import {chain as chainRamda} from 'ramda'

const duplicate = n => [n, n]

test('happy', () => {
  const fn = x => [x * 2]
  const list = [1, 2, 3]

  const result = chain(fn, list)

  expect(result).toEqual([2, 4, 6])
})

test('maps then flattens one level', () => {
  expect(chain(duplicate, [1, 2, 3])).toEqual([1, 1, 2, 2, 3, 3])
})

test('maps then flattens one level - curry', () => {
  expect(chain(duplicate)([1, 2, 3])).toEqual([1, 1, 2, 2, 3, 3])
})

test('flattens only one level', () => {
  const nest = n => [[n]]
  expect(chain(nest, [1, 2, 3])).toEqual([[1], [2], [3]])
})

test('can compose', () => {
  function dec(x) {
    return [x - 1]
  }
  function times2(x) {
    return [x * 2]
  }

  var mdouble = chain(times2)
  var mdec = chain(dec)
  expect(mdec(mdouble([10, 20, 30]))).toEqual([19, 39, 59])
})

test('@types/ramda broken test', () => {
  const score = {
    maths: 90,
    physics: 80,
  }

  const calculateTotal = score => {
    const {maths, physics} = score
    return maths + physics
  }

  const assocTotalToScore = (total, score) => ({...score, total})

  const calculateAndAssocTotalToScore = chainRamda(
    assocTotalToScore,
    calculateTotal
  )
  expect(() => calculateAndAssocTotalToScore(score)).toThrow()
})