withSpout在spark中是用來做DAG可視化的，它在代碼里的用法如下（以map為例，spark 1.5.0版本）

def map[U: ClassTag](f: T => U): RDD[U] = withScope {
  val cleanF = sc.clean(f)
  new MapPartitionsRDD[U, T](this, (context, pid, iter) => iter.map(cleanF))
}

因為對scala語法比較生疏，初次見面，一臉懵逼，這里的withScope是個什么用法？乍看一下有種java的implements Comparable的感覺。

其實，withScope是一個函數(shù)。

map()的函數(shù)體其實就是調(diào)用了一下withScope，將泛型什么的先去掉，代碼簡單來看就是下面這個樣子。

def map(f): RDD = withScope(body)

因為函數(shù)體只有簡單的一句，所以省略了大括號 "{ }"。
map函數(shù)補上大括號可以是這個樣子。

def map[U: ClassTag](f: T => U): RDD[U] = {
  withScope {
    val cleanF = sc.clean(f)
    new MapPartitionsRDD[U, T](this, (context, pid, iter) => iter.map(cleanF))
  }
}

函數(shù)只有單一參數(shù)，調(diào)用時，有時小括號和花括號是可以互換的

比如

rdd.map(x => x._1) //小括號
rdd.map{x => x._1} //花括號

這里，map()的參數(shù)是一個匿名函數(shù)，一句簡短代碼即可搞定。但是，當函數(shù)用一句搞不定時，就需要使用"{}"來界定代碼塊了。其實，于小括號和花括號之間來回切換的例子，在寫spark程序時，經(jīng)常遇到。
比如：

rdd.map(x => x._1).filter {
  ... //一些用一句代碼不易搞定的復雜過濾邏輯
}

回到withScope，它就是一個只有單一參數(shù)的函數(shù)。

private[spark] def withScope[U](body: => U): U = RDDOperationScope.withScope[U](sc)(body)

withScope的參數(shù)body是一個傳名參數(shù)。

傳名參數(shù)

傳名參數(shù) 僅在被使用時觸發(fā)實際參數(shù)的求值運算。 它們與 傳值參數(shù) 正好相反。
傳名參數(shù)的優(yōu)點是，如果它們在函數(shù)體中未被使用，則不會對它們進行求值。 另一方面，傳值參數(shù)的優(yōu)點是它們僅被計算一次。
傳名參數(shù)給人的感覺就像是字符串替換，最終把body替換成用戶寫的代碼。
跟蹤withScop的代碼可以看到body的使用。

body的調(diào)用

最開始理解有誤，以為body的類型是個無參函數(shù)。無參函數(shù)作為參數(shù)的話，可以參考下面的代碼中的print2()。

object TestMain {

  def main(args: Array[String]): Unit = {
    print1(getInt)
    println("-----------")
    print2(getInt)
  }

  def print1(f: => Int): Unit = { //傳名參數(shù)
    println(f)
    println(f.getClass)
  }

  def print2(f: () => Int): Unit = { //函數(shù)參數(shù)
    println(f)
    println(f.getClass)
  }

  def getInt(): Int = {
    1
  }
}

該代碼運行結(jié)果如下

1
int
-----------
<function0>
class com.iflytek.gnome.data.tmpsupport.main.TestMain$$anonfun$main$2

柯里化函數(shù)

我們看到上文中的withScope()又調(diào)用了RDDOperationScope中定義的withScope，而且調(diào)用方式有些奇怪。有兩個參數(shù)sc和body，而且用了兩個括號。
再去看RDDOperationScope中withScope的定義，參數(shù)中也用了兩個括號。第一個括號定義了sc和allowNesting參數(shù)，第二個括號定義了body參數(shù)。
這種形式在scala中叫做柯里化（currying）。

private[spark] def withScope[T](
      sc: SparkContext,
allowNesting: Boolean = false)(body: => T): T = {
  ...
}

柯里化是將原先一次性接受的參數(shù)，改成了鏈式接受的形式。這里引用《快學scala》中的例子說明。

def mul(x: Int)(y: Int) = x * y //定義柯里化函數(shù)
mul(6)(7) //調(diào)用柯里化函數(shù)

嚴格來講，首先調(diào)用mul(6)，返回的結(jié)果是函數(shù)(y: Int) => 6 * y （x被替換成了6）。而這個函數(shù)又被應(yīng)用到了7，最終得到42。
柯里化的本質(zhì)是什么呢？

其實，上面的mul()是如下形式的簡寫。mul()本質(zhì)上是定義了一個只有參數(shù)x的函數(shù)，其返回結(jié)果是另一個函數(shù)。

def mul(x: Int) = (y: Int) => x * y

如《快學scala》所說

如你所見，多參數(shù)不過是個虛飾，并不是編程語言的什么根本性的特質(zhì)。