currying 是函数式语言中经常遇到的一个概念，翻译成 柯里化，不是库里化。
currying 指的是将接收多个参数的函数变换成接收一个单一参数，并且返回接收余下的参数而且返回结果的新函数的技术。
说起来比较拗口，直接看下面的代码。
defadd(x: Int, y: Int): Int = x + y
//call add
add(1, 2)
add(3, 4)但是如果我们使用 currying 的写法，那么可以将两个参数分开，接收第一个参数(x)，然后返回一个函数，这个函数以第二个参数(y)为参数，返回结果：
defadd(x:Int) => (y: Int) = x + y然后我们就可以这样调用 add 了。
add(1)(2)
add(3)(4)scala 对于这种写法提供了语法糖，add 的 currying 写法我们可以更简单地写为：
defadd(x: Int)(y: Int): Int = x + y尝试将一个函数(这里指f)写成 curry 方式：
def curry[A, B, C](f: (A, B) => C): A => (B => C) = a => b => f(a, b)这里的 currying 函数，它接收两个参数，分别为 A 类型和 B 类型，然后返回一个 C 类型的结果。那么我们可以通过得到一个偏函数将其转化为 curry 的方式，即 A => (B => C)。具体流程是，用第一个参数 a ，得到一个函数，这个函数使用 b 作为参数，然后得到结果。这里中间的这个函数，是一个偏函数。
同样我们也可以写一个 uncurry 的方法（即将 currying 的函数f转化成非 currying 的）：
def uncurry[A, B, C](f: A => B => C): (A, B) => C =
(a, b) => f(a)(b) 这里在 currying 的过程中，使用了偏函数（partial applied function)，偏函数是什么？这个其实更好理解一些，通俗的讲，可以理解为定制化函数，比如我们有一个函数需要两个参数，那么如果我们返回固定其中一个参数的函数，那么我们就得到了一个偏函数：
defadd(x: Int, y: Int): Int = x + y
defadd1(y: Int): Int = add(1, y)这里我们就是固定了 add 函数中的 x 参数，然后返回了另外一个函数 add1，现在 add1 只有一个参数，我们直接可以调用 add1：
add1(5) //6可以看到，currying 和偏函数的主要区别就是，是否固定了参数，偏函数一旦固定参数之后，就返回了新的函数。而 currying 一般并没有固定参数，只是类似于使用了黑魔法，让多个参数的函数，最后变成了一个函数链。
其实在 C 语言中也有偏函数这种用法：
int foo(int a, int b, int c) {
return a + b + c;
}
int foo23(int a, int c) {
return foo(a, 23, c);
}但是在函数式语言中，偏函数以及 currying 能发挥更大的作用，原因是，函数式中，我们的参数还可以是函数。
defsum(f: Int => Int, a: Int, b: Int): Int =
if(a > b) 0
else f(a) + sum(a+1, b)这里有一个 sum 函数，它将 a 和 b 之间的所有的数，用 f 计算之后相加，比如：
sum(x => x * x, 1, 10)那么就是计算 1 到 10 之间所有数的平方和。但是如果我们要计算所有数的立方和呢，四次方呢？
固然我们可以将 f 传递成不同的值，但是我们也可以更简单地直接得到定制化之后的函数，即用不同的 f 得到不同的函数。
为了达到我们的目的，我们将函数写成 currying 形式：
defsum(f: Int => Int)(a: Int, b: Int): Int =
if(a >b) 0 else f(a) + sum(f)(a+1, b)这个时候 sum 函数的类型是什么呢？是：(Int => Int) => (( Int, Int) => Int)。第一层函数是一个参数类型为 Int => Int 的函数，其返回是一个函数，这个函数以 (Int, Int) => Int 类型为返回值。因此，如果我们传递不同的第一层函数的参数，即 Int => Int，那么就将得到不同的第二层函数，即类型为 (Int, Int) => Int 的函数。
因此，我们可以传入不同的 f，传入 f 之后，得到的函数就是以 a 和 b 为参数的函数：
为此我们将 sumT 函数定义成如下形式，使得 sumT 函数返回一个类型为 (Int, Int) => Int 的函数:
defsumT(f: Int => Int): (Int, Int) => Int = {
defsumF(a: Int, b: Int): Int =
if(a > b) 0
else f(a) + sumF(a+1, b)
sumF
}然后我们就可以传递不同的 f，获取不同的偏函数：
def sum3 = sum(x => x * x * x) //三次方
def sum4 = sum(x => x * x * x * x) //四次方这里可以看出，偏函数和 currying 是有很大的关联的。函数 currying 后，很容易实现某些偏函数。
在 scala 中，如果需要减少函数的参数，即固定函数的某些参数，那么使用偏函数即可。那么，currying的作用是什么？
作用有二，一个是可以将函数的参数写成{}形式，这对于参数是函数时可读性更好。
在currying之前，可能需要这样写：
using (new File(name), f => {......})在有了 currying 之后，我们可以写成更易读的方式：
using(new File(name)){ f => ......}第二个作用就是用于类型推导:
一般的 currying 可以写成
deff(arg1)(arg2)......(argn) => E
//等同于
deff(arg1)(arg2)......(argn-1) => { defg(argn) => E; g}
/.更简单点
deff(arg1)(arg2)......(argn-1) => (argsn => E)
//继续最后就可以写成
def f = args1 => args2......=>argsn => E这样写之后，scala 可以对参数之间的类型进行推导：左边参数的类型可以用于推导右边参数的类型，从而某些参数就可以简化写法：
def dropWhile[A](as: List[A], f: A => Boolean): List[A] = ......
//调用
dropWhile(List(1,2,3,4), (x: Int => x < 4))
//currying之后
dropWhile[A](as:List[A])(f: A => Boolean): List[A] = ......
//调用
dropWhile(List(1,2,3,4))(x => x < 4) //这里不再需要指明 x 的类型这样就可以用来结合匿名函数的下划线写出更加简洁的代码。
