柯里化详解

在计算机科学中，柯里化（Currying）是把接受多个参数的函数变换成接受一个单一参数(最初函数的第一个参数)的函数，并且返回接受余下的参数且返回结果的新函数的技术。这个技术由 Christopher Strachey 以逻辑学家 Haskell Curry 命名的，尽管它是 Moses Schnfinkel 和 Gottlob Frege 发明的。

柯里化(Currying)指的是将原来接受两个参数的函数变成新的接受一个参数的函数的过程。新的函数返回一个以原有第二个参数为参数的函数。

柯里化是很多高级编程语言拥有的特性，比如：JS、scala。

柯里化的好处：
1、参数复用。
2、提前返回。
3、 延迟计算/运行。

函数柯里化（currying）又称部分求值。一个 currying 的函数首先会接受一些参数，接受了这些参数之后，该函数并不会立即求值，而是继续返回另外一个函数，刚才传入的参数在函数形成的闭包中被保存起来。待到函数被真正需要求值的时候，之前传入的所有参数都会被一次性用于求值。

例如：
有一个函数，功能是计算每月的开销，我们实际关心的是整个月的开销总额。

var monthlyCost = 0; 
var cost = function( money ){ 
 monthlyCost += money; 
}; 
cost( 100 ); // 第 1 天开销
cost( 200 ); // 第 2 天开销
cost( 300 ); // 第 3 天开销
//cost( 700 ); // 第 30 天开销
alert ( monthlyCost ); // 输出：600 

通过这段代码可以看到，每天结束后我们都会记录并计算到今天为止花掉的钱。但我们其实并不太关心每天花掉了多少钱，而只想知道到月底的时候会花掉多少钱。也就是说，实际上只需要在月底计算一次。
如果在每个月的前 29 天，我们都只是保存好当天的开销，直到第 30 天才进行求值计算，这样就达到了我们的要求。虽然下面的 cost 函数还不是一个 currying 函数的完整实现，但有助于我们了解其思想：

var cost = (function(){ 
 var args = []; 
 return function(){ 
 if ( arguments.length === 0 ){ 
 var money = 0; 
 for ( var i = 0, l = args.length; i < l; i++ ){ 
 money += args[ i ]; 
 } 
 return money; 
 }else{ 
 [].push.apply( args, arguments ); 
 } 
 } 
})(); 
cost( 100 ); // 未真正求值
cost( 200 ); // 未真正求值
cost( 300 ); // 未真正求值
console.log( cost() ); // 求值并输出：600 

柯里化的通用方式：

function curry(fn){
    var args=Array.prototype.slice.call(arguments,1);
    return function(){
        var innerArgs = Array.prototype.slice.call(arguments);
        var finalArgs = args.concat(innerArgs);
        return fn.apply(null,finalArgs);
    );
}
function add(n1,n2){
  return n1+n2;
}
var cur=curry(add,5)
alert(cur(3))

上面的代码就完成了对add函数的柯理化，其原理十分简单。无非就是把上一层传入的参数再连接起来，传回原来的多参数函数。第一步args代表的就是要保留的那个参数。

使用函数柯里化解决问题

var currying = function( fn ){ 
 var args = []; 
 return function(){ 
 if ( arguments.length === 0 ){ 
 return fn.apply( this, args ); 
 }else{ 
 [].push.apply( args, arguments ); 
 return arguments.callee; 
 } 
 } 
}; 
var cost = (function(){ 
 var money = 0; 
 return function(){ 
 for ( var i = 0, l = arguments.length; i < l; i++ ){ 
 money += arguments[ i ]; 
 } 
 return money; 
 } 
})(); 
var cost = currying( cost ); // 转化成 currying 函数
cost( 100 ); // 未真正求值
cost( 200 ); // 未真正求值 
cost( 300 ); // 未真正求值
alert ( cost() ); // 求值并输出：600 

至此，我们完成了一个 currying 函数的编写。当调用 cost()时，如果明确地带上了一些参数，表示此时并不进行真正的求值计算，而是把这些参数保存起来，此时让 cost 函数返回另外一个函数。只有当我们以不带参数的形式执行 cost()时，才利用前面保存的所有参数，真正开始进行求值计算。

Scala 中的柯里化

# 定义一个函数
函数1 ：def add(x:Int,y:Int)=x+y
# 把函数变形：
函数2：def add(x:Int)(y:Int) = x + y
# 再变形：
函数3：def add(x:Int)=(y:Int)=>x+y

这3个函数在scala里都是支持的，函数1和函数2是普通函数，函数3是柯里化函数，我们看下执行上的区别：

# 函数1 ：def add(x:Int,y:Int)=x+y
scala> def add(x:Int,y:Int)=x+y
add: (x: Int, y: Int)Int

scala> add(2,3)
res0: Int = 5

# 函数2：def add(x:Int)(y:Int) = x + y
scala> def add(x:Int)(y:Int)=x+y
add: (x: Int)(y: Int)Int

scala> add(2)(3)
res0: Int = 5

# 函数3：def add(x:Int)=(y:Int)=>x+y
scala> def add(x:Int)=(y:Int)=>x+y
add: (x: Int)Int => Int

scala> add(2)
res0: Int => Int = $$Lambda$1058/1404150776@7d97e06c

scala> add(3)
res1: Int => Int = $$Lambda$1058/1404150776@523a7801

scala> add(2)(3)
res2: Int = 5

通过上面的计算过程可以看出，函数3，也是需要传2个参数的，如果传了2个参数，马上会计算出结果；如果只传了一个参数，那么会生成一个临时的结果res0，这里面并没有把结果计算出来，而是把运算缓存起来了，当第二个参数也传进来了，就会开始计算最终结果。

再举上面的计算每月总开销的例子，柯里化函数并不关心中间结果，也不会去计算中间结果，只会做一个缓存计算操作的操作，在最终需要执行的时候才去执行

如果你有更好的理解柯里化的方式，欢迎在评论区交流。