JS 函数的柯里化与反柯里化

=====================================

函数的柯里化与反柯里化

[这是一篇比较久之前的总结了，若有错漏，请指正！]

柯里化 currying

维基百科的名词解释：柯里化（英语：Currying），又译为卡瑞化或加里化，是把接受多个参数的函数变换成接受一个单一参数（最初函数的第一个参数）的函数，并且返回接受余下的参数而且返回结果的新函数的技术。这个技术由 Christopher Strachey 以逻辑学家哈斯凯尔·加里命名的，尽管它是 Moses Schönfinkel 和 Gottlob Frege 发明的。

定义：

函数柯里化，是固定部分参数，返回一个接受剩余参数的函数，也称为部分计算函数，目的是为了缩小适用范围，创建一个针对性更强的函数。

特点：

提高了代码的合理性，更重的它突出一种思想---降低适用范围，提高适用性。
对于一个已有函数，对其约定好其中的某些参数输入，然后生成一个更有好的、更符合业务逻辑的函数。

柯里化（currying），我们可以这么理解：

柯里化就是一个函数在参数没给全时返回另一个函数，返回的函数的参数正好是余下的参数。
比如：你制定了x和y, 如2的3次方,就返回8, 如果你只制定x为2,y没指定, 那么就返回一个函数：2的y次方, 这个函数只有一个参数:y。这样就非常容易理解吧。

1. 提高适用性
2. 延迟执行
3. 固定易变因素
   
   http://www.cnblogs.com/pigtail/p/3447660.html - 前端开发者进阶之函数反柯里化unCurrying

function currying(fn) {

var __args = Array.prototype.slice.call(arguments, 1);

return function () {

var __inargs = slice.call(arguments);

return fn.apply(null, __args.concat(__inargs));

};

}

提高适用性

    function square(i) {
        return i * i;
    }

    function dubble(i) {
        return i *= 2;
    }

    function map(handeler, list) {
        return list.map(handeler);
    }

    // 数组的每一项平方
    map(square, [1, 2, 3, 4, 5]);
    map(square, [6, 7, 8, 9, 10]);
    map(square, [10, 20, 30, 40, 50]);

    // 数组的每一项加倍
    map(dubble, [1, 2, 3, 4, 5]);
    map(dubble, [6, 7, 8, 9, 10]);
    map(dubble, [10, 20, 30, 40, 50]);

例子中，创建了一个map通用函数，用于适应不同的应用场景。显然，通用性不用怀疑。
同时，例子中重复传入了相同的处理函数：square和dubble。
应用中这种可能会更多。当然，【通用性的增强必然带来适用性的减弱】

    使用currying
    function square(i) {
        return i * i;
    }

    function dubble(i) {
        return i *= 2;
    }

    function map(handeler, list) {
        return list.map(handeler);
    }

    var mapSQ = currying(map, square);
    mapSQ([1, 2, 3, 4, 5]);
    mapSQ([6, 7, 8, 9, 10]);
    mapSQ([10, 20, 30, 40, 50]);
    // ......

    var mapDB = currying(map, dubble);
    mapDB([1, 2, 3, 4, 5]);
    mapDB([6, 7, 8, 9, 10]);
    mapDB([10, 20, 30, 40, 50]);
    // ......
    【缩小了函数的适用范围，但同时提高了函数的适用性】

延迟执行

    var curry = function(fn){
        var _args = [];

        return function(){
            if(arguments.length === 0){
                return fn.apply(this,_args);
            }

            [].push.apply(_args,arguments);

            // console.log(arguments.callee);
            return arguments.callee;
        }
    }

    var sum=0;
    var add =function(){
        for (var i = 0,c; c=arguments[i++];){
            sum+=c;
        }
        return sum;
    };

    var add = curry(add);

    var res1 = add(1)(2)(3)();
    console.log(res1)
    // 6

    // add(1);
    // add(2);
    // add(3);
    // var res2=add();
    // console.log(res2)

currying函数, 便可以延迟到最后一刻才一起计算, 好处不言而喻, 在很多场合可以避免无谓的计算, 节省性能, 也是实现惰性求值的一种方案.

固定易变因素

提前把易变因素，传参固定下来，生成一个更明确的应用函数。最典型的代表应用，是bind函数用以固定this这个易变对象。
Function.prototype.bind = function(context) {
    var _this = this,
        _args = Array.prototype.slice.call(arguments, 1);
    return function() {
         return _this.apply(context, _args.concat( Array.prototype.slice.call(arguments)));
    }
}

bind函数本身就是柯里化的一种体现，函数可以通过bind绑定新的上下文环境来改变其所处的上下文，并生成一个新的函数。这里第一次传入的参数_args就是函数本身的信息，被保存在了函数的闭包之中，就是柯里化的属性；之后的第二个参数arguments，就是在函数调用的过程中再传递的剩余参数。

反柯里化 uncurrying

反科里化的话题来自javascript之父Brendan Eich去年的一段twitter.

参考

http://www.jb51.net/article/32435.htm - javascript中有趣的反柯里化深入分析

http://sombie.diandian.com/post/2013-06-28/40050585369 -【WEB前端】由JavaScript反柯里化所想到的

定义

让你自定义的对象拥有原生JS对象的方法，并利用鸭子类型的特征扩展其使用范围。

作用

扩展函数适用范围的方法
把函数也当作普通数据来使用, 当函数名本身是个变量的时候, 这种调用方法特别方便.
扩大函数的适用性，使本来作为特定对象所拥有功能的函数可以对全体对象使用

Function.prototype.uncurry = function() {
    var _this = this
    return function() {
        return Function.prototype.call.apply(_this, arguments)
    }
}

短小精悍，科学上讲，浓缩的都是精品，但越精品的往往越难以理解。分解一下：
1 为Function原型添加unCurrying方法，这样所有的function都可以被借用；
2 返回一个借用其它方法的函数，这是目的；
3 借用call方法实现，但call方法参数传入呢？借用apply，至此完毕。

最终是把this.method转化成 method(this,arg1,arg2....)以实现方法借用和this的泛化。

用法

foo = somefun.uncurry();

foo(obj, args...) <==> obj.somefun(args)。

例：让Object也拥有push的方法

var push = Array.prototype.push.uncurry()

push({},'aa');

反柯里化的最简方式实现

//将原生的bind函数转换为全局的bind
var bind = Function.prototype.call.bind(Function.prototype.bind);
module={
    debug:function(){
        console.log.apply(console,arguments);
    }
};
var debug = bind(module.debug,module);

debug('adsfadsf','444',[1,2,3]);
//输出：adsfadsf 444 [1, 2, 3] 

//将原生的push函数转换为全局的push
var push = Function.prototype.call.bind([].push);

var person ={
    name:'aa',
    age:33
};
push(person,'44');

debug(person);
//输出：Object {0: "44", name: "aa", age: 33, length: 1} 

为什么push函数可以应用到非数组对象上？
v8引擎里面Array.prototype.push的代码
function ArrayPush() {
    var n = TO_UINT32( this.length );
    var m = %_ArgumentsLength();
    for (var i = 0; i < m; i++) {
        this[i+n] = %_Arguments(i); //属性拷贝
        this.length = n + m; //修正length
        return this.length;
    }
}
ArrayPush方法没有对this的类型做任何显示的限制，所以理论上任何对象都可以被传入ArrayPush这个访问者。
push可以应该到类似数组类型的对象上，即鸭子类型

动态语言中重要的鸭子类型思想

故事：

很久以前有个皇帝喜欢听鸭子呱呱叫，于是他召集大臣组建一个一千只鸭子的合唱团。大臣把全国的鸭子都抓来了，最后始终还差一只。有天终于来了一只自告奋勇的鸡，这只鸡说它也会呱呱叫，好吧在这个故事的设定里，它确实会呱呱叫。 后来故事的发展很明显，这只鸡混到了鸭子的合唱团中。— 皇帝只是想听呱呱叫，他才不在乎你是鸭子还是鸡呢。

这个就是鸭子类型的概念，在javascript里面，很多函数都不做对象的类型检测，而是只关心这些对象能做什么。

Array构造器和String构造器的prototype上的方法就被特意设计成了鸭子类型。这些方法不对this的数据类型做任何校验。这也就是为什么arguments能冒充array调用push方法.