随便说说函数柯里化

什么是柯里化（Currying）？
柯里化是以数学家、逻辑学家Haskell Brooks Curry的名字命名的，与咖喱无关。编程语言Haskell也是以他的名字命名的。
所谓柯里化，是指将接受多个参数的函数的求值过程，转变为一系列子函数的链式求值过程的方法。这一系列子函数中，每个子函数的参数列表都是原来参数列表的子集。并且除了最后一个子函数之外，其他子函数都会按序接受参数，而返回一个新的函数。

简单来讲，如果在集合X、Y、Z上定义函数f: (X × Y) → Z，那么将f柯里化，会构造出新函数f': X → (Y → Z)。也就是说，函数f'接受X中的参数，然后返回一个由Y映射到Z的函数，进而从该函数得到结果。这可以表示为f'(x)(y)=f(x, y)。与这个过程相反的过程就叫反柯里化（Uncurrying）。

用Java来举个例子，假设有一个将两数相加的方法：

int add(int x, int y) {
    return x + y;
}

将其柯里化之后，就是这样的：

Function<Integer, Function<Integer, Integer>> add() {
    return x -> y -> x + y;
}

如果用Scala的话，看起来更加简洁一些：

def add(x: Int)(y: Int): Int = {
    x + y
}

它实际上是以下这种形式的简写：

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

所以，我们也可以简单地认为，函数柯里化之后相当于将其原来的参数列表分拆成了多个参数列表进行调用，因此Scala官方文档中也将其称为“multiple parameter lists”。

看了上面的例子之后，我们可能都会感觉柯里化没什么卵用，“只是块语法糖而已嘛”。但它在像Scala这样推崇函数式编程的语言中确实有奇效。例如在Scala内部的SeqLike特征中，有个corresponds()方法：

  def corresponds[B](that: GenSeq[B])(p: (A,B) => Boolean): Boolean = {
    val i = this.iterator
    val j = that.iterator
    while (i.hasNext && j.hasNext)
      if (!p(i.next(), j.next()))
        return false

    !i.hasNext && !j.hasNext
  }

它按照一定条件来比较两个序列的对应性，并返回true或false。它接受两个分开的参数：要比较的另一个序列that、比较条件p，其中p又是一个函数，这就是典型的柯里化。
举个栗子，如果我们有多个字符串组成的序列（即Seq[String]）a和b，那么我们要比较a内的每个字符串在不区分大小写的情况下是否与b内的字符串相等，就可以这样写，非常简单：

a.corresponds(b)(_.equalsIgnoreCase(_))

在Spark的源码中也广泛运用了函数柯里化。如Spark Core系列文章中的代码#4.1，即SparkContext.parallelize()方法中，withScope出现的地方就有点诡异：

  def parallelize[T: ClassTag](
      seq: Seq[T],
      numSlices: Int = defaultParallelism): RDD[T] = withScope {
    assertNotStopped()
    new ParallelCollectionRDD[T](this, seq, numSlices, Map[Int, Seq[String]]())
  }

实际上withScope()是个方法，因为它只接受一个参数，所以圆括号直接用花括号代替了，这在Scala中是允许的。其最终实现位于RDDOperationScope.withScope()方法中：

  private[spark] def withScope[T](
      sc: SparkContext,
      name: String,
      allowNesting: Boolean,
      ignoreParent: Boolean)(body: => T): T = {
    // Save the old scope to restore it later
    val scopeKey = SparkContext.RDD_SCOPE_KEY
    val noOverrideKey = SparkContext.RDD_SCOPE_NO_OVERRIDE_KEY
    val oldScopeJson = sc.getLocalProperty(scopeKey)
    val oldScope = Option(oldScopeJson).map(RDDOperationScope.fromJson)
    val oldNoOverride = sc.getLocalProperty(noOverrideKey)
    try {
      if (ignoreParent) {
        // Ignore all parent settings and scopes and start afresh with our own root scope
        sc.setLocalProperty(scopeKey, new RDDOperationScope(name).toJson)
      } else if (sc.getLocalProperty(noOverrideKey) == null) {
        // Otherwise, set the scope only if the higher level caller allows us to do so
        sc.setLocalProperty(scopeKey, new RDDOperationScope(name, oldScope).toJson)
      }
      // Optionally disallow the child body to override our scope
      if (!allowNesting) {
        sc.setLocalProperty(noOverrideKey, "true")
      }
      body
    } finally {
      // Remember to restore any state that was modified before exiting
      sc.setLocalProperty(scopeKey, oldScopeJson)
      sc.setLocalProperty(noOverrideKey, oldNoOverride)
    }
  }

这个方法能够保证执行函数体body时，在body内部生成的所有RDD都位于同一个操作域内。它是我们在Spark Web UI展示的DAG图中能够看到RDD之间转化关系的基础。

总的来说，柯里化的意义主要有三点：

参数复用
复杂逻辑分拆
延迟执行

嘛，就这样。晚安。