这段scala代码是怎么回事？回调函数

Question

/**
  * Returns the number of rows in the [[Dataset]].
  * @group action
  * @since 1.6.0
  */
def count(): Long = withCallback("count", groupBy().count()) { df =>
  df.collect(needCallback = false).head.getLong(0)
}

/**
  * Wrap a Dataset action to track the QueryExecution and time cost, then report to the
  * user-registered callback functions.
  */
private def withCallback[U](name: String, df: DataFrame)(action: DataFrame => U) = {
  try {
      df.queryExecution.executedPlan.foreach { plan => plan.resetMetrics()
    }
    val start = System.nanoTime()
    val result = action(df)
    val end = System.nanoTime()
    sqlContext.listenerManager.onSuccess(name, df.queryExecution, end - start)
    result
  } catch {
  case e: Exception =>
    sqlContext.listenerManager.onFailure(name, df.queryExecution, e)
    throw e
  }
}

这是怎么回事？我不明白count（）是如何既等于withCallback又有一个主体的；不知何故，它是在withCallback返回的dataframe上调用的，但我不明白语法。

Answer 1

count()方法实际上没有自己的主体。看起来像count()的正文实际上是一个函数文本，它定义了With Callback的“action”参数。严格地说，count()本身只是对方法With callback（name,df）（action）的调用。（在Scala中，方法可以有多个参数列表。）with callback的值是result，也就是action函数的计算结果。

然而，你正在经历的“困惑”是有意为之的。这个习惯用法--一个具有类型为函数或名值的结束参数列表的方法--允许人们定义在语法上看起来像语言扩展的东西。我们习惯于有特殊语法的语言，比如...

try {
  // your code here
}

在Scala中，您可以编写自己的函数，如...

// don't ask me why you would want to do this
def unreliably[T]( operation : =>T ) : Option[T] = {
   if (scala.math.random < 0.1) Some(operation) else None
}

unreliably {
  // your code here
}

它看起来就像新的语言语法！为了让它更像你的激励示例，我们可以修改定义，使其必须参数列表······

// don't ask me why you would want to do this
def unreliably[T]( probability : Double )( operation : =>T ) : Option[T] = {
   if (scala.math.random < probability) Some(operation) else None
}

现在，我们可以调用函数为...

unreliably( probability = 0.9 ) {
  // your code here
}

...你的代码有90%的机会被执行。代码定义了一个表达式，而不仅仅是一些无价值的语句，因此您还可以编写

val result = unreliably( probability = 0.9 ) {
   "great day"
}

println(s"""It's a ${result.getOrElse("terrible day")}.""")