函数式中的 currying

currying 是函数式语言中经常遇到的一个概念，翻译成 柯里化，不是库里化。

currying 指的是将接收多个参数的函数变换成接收一个单一参数，并且返回接收余下的参数而且返回结果的新函数的技术。

说起来比较拗口，直接看下面的代码。

    def add(x: Int, y: Int): Int = x + y

    //call add
    add(1, 2)
    add(3, 4)

但是如果我们使用 currying 的写法，那么可以将两个参数分开，接收第一个参数(x)，然后返回一个函数，这个函数以第二个参数(y)为参数，返回结果：

    def add(x:Int) => (y: Int) = x + y

然后我们就可以这样调用 add 了。

    add(1)(2)
    add(3)(4)

scala 对于这种写法提供了语法糖，add 的 currying 写法我们可以更简单地写为：

    def add(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)，偏函数是什么？这个其实更好理解一些，通俗的讲，可以理解为定制化函数，比如我们有一个函数需要两个参数，那么如果我们返回固定其中一个参数的函数，那么我们就得到了一个偏函数：

    def add(x: Int, y: Int): Int = x + y
    def add1(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 能发挥更大的作用，原因是，函数式中，我们的参数还可以是函数。

def sum(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 形式：

def sum(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 的函数:

def sumT(f: Int => Int): (Int, Int) => Int = {
    def sumF(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 可以写成

def f(arg1)(arg2)......(argn) => E
//等同于
def f(arg1)(arg2)......(argn-1) => { def g(argn) => E; g}
/.更简单点
def f(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 的类型

这样就可以用来结合匿名函数的下划线写出更加简洁的代码。

currying 也可以在某些只允许使用单个参数的函数的情景下发挥作用，利用 currying 使用层层嵌套的单参数函数，可以实现语法层面的多参数函数。

---

[1]: http://stackoverflow.com/questions/8063325/usefulness-as-in-practical-applications-of-currying-v-s-partial-application-i

[2]: http://www.vaikan.com/currying-partial-application/

[3]: http://www.codecommit.com/blog/scala/function-currying-in-scala

[4]: https://book.douban.com/subject/26772149/

[5]: https://www.coursera.org/learn/progfun1/lecture/fOuQ9/lecture-2-2-currying