一、函数组合
    又叫 饲养函数，compose。由纯函数、偏函数、柯理化函数组成，能够控制数据传递，形成一种有效执行的组合。
    左倾：在函数的参数中执行函数

    1. function toUpperCase(str){
    2.     return str.toUpperCase()
    3. }
    5. function exclain (str){
    6.     return str + '!'
    7. }
    9. //将函数组合起来,返回一个新函数，将组合的函数包裹起来。
    10. function ComposeToUpperCaseAndExclain(toUppercaseFn,ExclainFn){
    11.     return function(str){ //关键步骤，返回一个包裹函数组合的函数。
    12.       return ExclainFn(toUppercaseFn(str)) //左倾，先执行参数中的函数，再执行函数。
    13.   }
    14. }
    15. 数据在函数之间（像一个管道）流动处理

    抽象组合工具函数
    关键点： 函数个数不定，左倾（这里用reduceRight就很方便了）。

    1. function split(str){
    2.     return str.split('')
    3. }
    5. function reverse(arr){
    6.   arr.reverse()
    7.     return arr
    8. }
    10. function join(arr){
    11.   return arr.join('~')
    12. }
    14. function toUpperCase(str){
    15.     return str.toUpperCase()
    16. }
    18. function exclain(str){
    19.     return str + '!'
    20. }
    22. function composeFunction(){
    23.     let len = argsArr.length - 1,
    24.       argsArr = Array.prototype.slice.call(arguments);
    25.   return function(x){
    26.       let res = argsArr[len](x);
    27.     while(len--){
    28.           console.log(res)
    29.             res = argsArr[len](res)
    30.     }
    31.     return res
    32.   }
    33. }
    35. let compositionFn = composeFunction(exclain,toUpperCase,join,reverse,split);
    37. function composingFunctionWithReduceRight(){
    38.     let args = [...arguments];
    39.   return function(x){
    40.     console.log(x)
    41.       let res = args.reduceRight((accumulotar,elem,index)=>{
    42.       console.log(accumulotar,elem,index)
    43.       return elem(accumulotar)
    44.     },x)
    45.     return res
    46.   }
    47. }
    49. console.log(compositionFn('not a bum'))

    二、结合律 associativity
    什么是结合律：在函数组合时，先将参数进行组合，不同组合方式得到的结果是一样的。不管怎么结合，都是对
    链式操作的分组串联包裹

    1. function split(str){
    2.     return str.split('')
    3. }
    5. function reverse(arr){
    6.   arr.reverse()
    7.     return arr
    8. }
    10. function join(arr){
    11.   return arr.join('~')
    12. }
    14. function composingFunctionWithReduceRight(){
    15.     let args = [...arguments];
    16.   return function(x){
    17.       let res = args.reduceRight((accumulotar,elem,index)=>{
    18.       return elem(accumulotar)
    19.     },x)
    20.     return res
    21.   }
    22. }
    24. let compositionFn1 = composingFunctionWithReduceRight(join,reverse,split),
    25.         compositionFn2 = composingFunctionWithReduceRight(join,composingFunctionWithReduceRight(reverse,split)),
    26.     compositionFn3 = composingFunctionWithReduceRight(composingFunctionWithReduceRight(join,reverse),split);

    三、pointfree，执行函数时，无需传入数据参数（返回了一个闭包新函数，新函数会接受自己的数据参数）

    1. function compose (){
    2.     let args = [...arguments];
    3.   return function(x){
    4.       let res = args.reduceRight((accumulotar,elem=>{
    5.         return elelm(x)
    6.     },x)
    7.     return res
    8.   }
    9. }
    11. let fn = compose() //调用函数时无需传递数据参数
    1. function classFilter(data){
    2.     return data.classes > 20 && data //如果满足条件，会继续走返回最后一个值
    3. }
    4. function isFreeFilter(data){
    5.     return data.isFree && data
    6. }
    8. function composingFunctionWithReduceRight(){
    9.     let args = [...arguments];
    10.   return function(x){
    11.       let res = args.reduceRight((accumulotar,elem,index)=>{
    12.       return elem(accumulotar)
    13.     },x)
    14.     return res
    15.   }
    16. }
    18. let classesData = [
    19.   { classes: 21, isFree: true},  
    20.   { classes: 11, isFree: false},
    21.   { classes: 31, isFree: true},
    22.   { classes: 19, isFree: true},
    23.   { classes: 20, isFree: true}
    24. ]
    26. let arr  = [],
    27.     f = null;
    28. classesData.forEach((item)=>{
    29.     f = composingFunctionWithReduceRight(classFilter, isFreeFilter);
    30.     f(item) && arr.push(item)
    31. })
    32. console.log(arr)