SOURCE

// 对参数的处理

// f(x) = a(x) + b
// function a(arg, str) {
//     something
// }

// 任何复用的东西都可以用高阶 柯里化 来实现
// 思想：把问题转换为一元函数，在用函数来抽像、复用

function curry (fn) {
  const c = (...args) => (args.length === fn.length) ?
          fn(...args) : (..._args) => c(...args, ..._args)
  return c
}

function add1 (a,b,c,d,e,f) {
    return a + b + c + d + e + f
}

// 对参数的处理，只要参数不等于定义函数的参数长度，就返回一个函数给你，利用闭包访问之前的参数
// 执行 a()()()()()()()()()()
// 本质上是高阶函数的另外一种用法以及利用闭包、函数作用域等

// 不断嵌套，利用闭包可以访问到之前的变量

function sum (a) {
    return (b) => {
        return (c) => {
            return (d) => {
                return a + b + c + d
            }
        }
    }
}

function curryingHelper(fn) {
  const c = (...args) => (args.length === fn.length) ?
          fn(...args) : (..._args) => c(...args, ..._args)
  return c
}

const countAdd = sum(1)(2)(3)(4)
console.log('基本:' + countAdd)


const pushA = a => b => a + b
console.log(pushA(3)(4))

function sum1 (a,b,c,d,e,f) {
    return a + b + c + d + e + f
}

// es6 写法
function curry1 (fn) {
    const cb = (...args) => args.length === fn.length ? 
      fn(...args) : (..._args) => cb(...args, ..._args)
    return cb
}
const conutSum1 = curry1(sum1)

console.log(conutSum1(1,3,4,5,6,7))
console.log(conutSum1(1,3)(4,5)(6,7))

// es5 写法
function curry2 (fn, args) {
    const len = fn.length
    const _args = args || []
    return function () {
        const newArgs = _args.concat(Array.prototype.slice.call(arguments))
        if (newArgs.length >= len) {
            return fn.apply(this, newArgs)
        } else {
            return curry2.call(this, fn, newArgs)
        }
    }
}

const conutSum2 = curry2(sum1)

console.log(conutSum2(1,3,4,5,6,7))
console.log(conutSum2(1,3)(4,5)(6,7))

// 返回里面的fn
function curry3 (fn, args) {
    const len = fn.length
    let _args = args || []
    const cb = function () {
        const newArgs = _args.concat(Array.prototype.slice.call(arguments))
        if (newArgs.length >= len) {
            return fn.apply(this, newArgs)
        } else {
            _args = newArgs
          return cb
        }
    }
    return cb
}

const conutSum3 = curry3(sum1)
console.log(conutSum3(1,3,4,5,6,7))

console.log(conutSum3(1,3)(4,5)(6,7))

// ES5
const curry4 = function curry (fn, arr) {
  let arrs = arr || []

  return function () {
    let args = [].slice.call(arguments)
    let arg = arrs.concat(args)

    return arg.length >= fn.length
      ? fn.apply(null, arg)
      : curry(fn, arg)
  }
}

const conutSum4 = curry4(sum1)
console.log(conutSum4(1,3,4,5,6,7))

console.log(conutSum4(1,3)(4,5)(6,7))

const curry5= function (fn, arr) {
    let arrs = arr || []
    return function () {
        const _args = [].slice.call(arguments)
        let arg = arrs.concat(_args)
        return arg.length >= fn.length 
        ? fn.apply(null,arg)
        : curry5(fn, arg)
    }
}

// 用什么来判断参数是否可以执行？
// 递归,且要把之前的参数一起传入（参数是之前参数与传进来参数组合）
// 很明显第一反应是需要使用递归，这样才能返回一系列的函数。
// 而递归的结束条件就是接受了原函数数量的参数，所以重点就是参数的传递
// const c = ()

// return cb()