在Scala里，带有其他函数做参数的函数叫做高阶函数，使用高阶函数可以简化代码。

减少重复代码

有这样一段代码，查找当前目录样以某一个字符串结尾的文件：

object FileMatcher {
  private def filesHere = (new java.io.File(".")).listFiles
  def filesEnding(query: String) =
    for (file <- filesHere; if file.getName.endsWith(query))
      yield file
}

如果，我们想查找包含某一个字符串的文件，则代码需要修改为：

def filesContaining(query: String) =
  for (file <- filesHere; if file.getName.contains(query))
    yield file

上面的改动只是使用了 contains 替代 endsWith，但是随着需求越来越复杂，我们要不停地去修改这段代码。例如，我想实现正则匹配的查找，则代码会是下面这个样子：

def filesRegex(query: String) =
  for (file <- filesHere; if file.getName.matches(query))
    yield file

为了应变复杂的需求，我们可以进行重构代码，抽象出变化的代码部分，将其声明为一个方法：

def filesMatching(query: String,matcher: (String, String) => Boolean) = {
  for (file <- filesHere; if matcher(file.getName, query))
    yield file
}

这样，针对不同的需求，我们可以编写不同的matcher方法实现，该方法返回一个布尔值。

有了这个新的 filesMatching 帮助方法，你可以通过让三个搜索方法调用它，并传入合适的函数来简化它们：

def filesEnding(query: String) = filesMatching(query, _.endsWith(_))

def filesContaining(query: String) = filesMatching(query, _.contains(_))

def filesRegex(query: String) = filesMatching(query, _.matches(_))

上面的例子使用了占位符，例如， filesEnding 方法里的函数文本 _.endsWith(_) 其实就是：

(fileName: String, query: String) => fileName.endsWith(query)

因为，已经确定了参数类型为字符串，故上面可以省略参数类型。由于第一个参数 fileName 在方法体中被第一个使用，第二个参数 query 第二个使用，你也可以使用占位符语法：_.endsWith(_)。第一个下划线是第一个参数文件名的占位符，第二个下划线是第二个参数查询字串的占位符。

因为query参数是从外部传过来的，其可以直接传递给matcher函数，故filesMatching可以只需要一个参数：

object FileMatcher {
  private def filesHere = (new java.io.File(".")).listFiles

  private def filesMatching(matcher: String => Boolean) =
    for (file <- filesHere; if matcher(file.getName))
      yield file

  def filesEnding(query: String) = filesMatching(_.endsWith(query))

  def filesContaining(query: String) = filesMatching(_.contains(query))

  def filesRegex(query: String) = filesMatching(_.matches(query))
}

上面的例子使用了函数作为第一类值帮助你减少代码重复的方式，另外还演示了闭包是如何能帮助你减少代码重复的。前面一个例子里用到的函数文本，如 _.endsWith(_)和_.contains(_)都是在运行期实例化成函数值而不是闭包，因为它们没有捕获任何自由变量。

举例来说，表达式_.endsWith(_)里用的两个变量都是用下划线代表的，也就是说它们都是从传递给函数的参数获得的。因此，_.endsWith(_)使用了两个绑定变量，而不是自由变量。

相对的，最近的例子里面用到的函数文本_.endsWith(query)包含一个绑定变量，下划线代表的参数和一个名为 query 的自由变量。仅仅因为 Scala 支持闭包才使得你可以在最近的这个例子里从 filesMatching 中去掉 query 参数，从而更进一步简化了代码。

另外一个例子，是循环集合时可以使用exists方法来简化代码。以下是使用了这种方式的方法去判断是否传入的 List 包含了负数的例子:

def  containsNeg(nums: List[Int]): Boolean = {
    var exists = false
    for (num <- nums)
        if (num < 0)
            exists = true
    exists
}

采用和上面例子同样的方法，我们可以抽象代码，将重要的逻辑抽离到一个独立的方法中去实现。对于上面的查找判断是否存在的逻辑，Scala中提供了高阶函数 exists 来实现，代码如下：

def containsNeg(nums: List[Int]) = nums.exists(_ < 0)

同样，如果你要查找集合中是否存在偶数，则可以使用下面的代码：

def containsOdd(nums: List[Int]) = nums.exists(_ % 2 == 1)

柯里化

当函数有多个参数列表时，可以使用柯里化函数来简化代码调用。例如，对下面的函数，它实现两个 Int 型参数，x 和 y 的加法：

scala> def plainOldSum(x: Int, y: Int) = x + y
plainOldSum: (Int,Int)Int

scala> plainOldSum(1, 2)
res4: Int = 3

我们可以将其柯里化，代之以一个列表的两个Int参数，实现如下：

scala> def curriedSum(x: Int)(y: Int) = x + y
curriedSum: (Int)(Int)Int

scala> curriedSum(1)(2)
res5: Int = 3

当你调用 curriedSum，你实际上背靠背地调用了两个传统函数。第一个函数调用带单个的名为 x 的 Int 参数，并返回第二个函数的函数值，第二个函数带 Int 参数 y。

你可以使用偏函数，填上第一个参数并且部分应用第二个参数。

scala> val onePlus = curriedSum(1)_
onePlus: (Int) => Int = <function>

curriedSum(1)_里的下划线是第二个参数列表的占位符。结果就是指向一个函数的参考，这个函数在被调用的时候，对它唯一的Int参数加1并返回结果：

scala> onePlus(2)
res7: Int = 3

可变长度参数

类似柯里化函数，对于同类型的多参数列表，我们还可以使用可变长度参数，这部分内容，请参考《Scala基本语法和概念》中的可变长度参数。

贷出模式

前面的例子提到了使用函数作为参数，我们可以将这个函数的执行结果再次作为参数传入函数，即双倍控制结构：能够重复一个操作两次并返回结果。

下面是一个例子：

scala> def twice(op: Double => Double, x: Double) = op(op(x))
twice: ((Double) => Double,Double)Double

scala> twice(_ + 1, 5)
res9: Double = 7.0

上面例子中 op 的类型是 Double => Double，就是说它是带一个 Double 做参数并返回另一个 Double 的函数。这里，op函数等同于：

def add(x:Int)=x+1

op函数会执行两次，第一次是执行add(5)=6，第二次是执行add(add(5))=add(6)=6+1=7。

任何时候，你发现你的代码中多个地方有重复的代码块，你就应该考虑把它实现为这种双重控制结构。

考虑这样一种需求：打开一个资源，对它进行操作，然后关闭资源，你可以这样实现：

def withPrintWriter(file: File, op: PrintWriter => Unit) {
  val writer = new PrintWriter(file)
  try {
    op(writer)
  } finally {
    writer.close()
  }
}

有了这个方法，你就可以这样使用:

withPrintWriter(new File("date.txt"), writer => writer.println(new java.util.Date) )

注意：这里和上面的例子一样，使用了=> 来映射式定义函数，其可以看成是没有参数的函数，返回一个匿名函数；调用的时候是调用这个返回的匿名函数。

使用这个方法的好处是，调用这个方法只需要关注如何操作资源，而不用去关心资源的打开和关闭。这个技巧被称为贷出模式：loan pattern，因为该函数要个模板方法一样，实现了资源的打开和关闭，而将使用 PrintWriter 操作资源贷出给函数，交由调用者来实现。

例子里的 withPrintWriter 把 PrintWriter 借给函数 op。当函数完成的时候，它发出信号说明它不再需要“借”的资源。于是资源被关闭在 finally 块中，以确信其确实被关闭，而忽略函数是正常结束返回还是抛出了异常。

因为，这个函数有两个参数，所以你可以将该函数柯里化：

def withPrintWriter(file: File)(op: PrintWriter => Unit) {
  val writer = new PrintWriter(file)
  try {
    op(writer)
  } finally {
    writer.close()
  } 
}

这样的话，你可以如下方式调用：

val file = new File("date.txt")
withPrintWriter(file) {
    writer => writer.println(new java.util.Date)
}

这个例子里，第一个参数列表，包含了一个 File 参数，被写成包围在小括号中。第二个参数列表，包含了一个函数参数，被包围在大括号中。

当一个函数只有一个参数时，可以使用大括号代替小括号。

传名参数 by-name parameter

《Programming in Scala》的第九章提到了传名参数这个概念。其中举的例子是：实现一个称为myAssert的断言函数，该函数将带一个函数值做输入并参考一个标志位来决定该做什么。

如果没有传名参数，你可以这样写myAssert：

var assertionsEnabled = true 
def myAssert(predicate: () => Boolean) =  
    if (assertionsEnabled && !predicate())  
        throw new AssertionError

这个定义是正确的，但使用它会有点儿难看：

myAssert(() => 5 > 3)

你或许很想省略函数文本里的空参数列表和=>符号，写成如下形式：

myAssert(5 > 3) // 不会有效，因为缺少() =>

传名函数恰好为了实现你的愿望而出现。要实现一个传名函数，要定义参数的类型开始于=>而不是() =>。例如，你可以通过改变其类型() => Boolean为=> Boolean，把myAssert的predicate参数改为传名参数。

def byNameAssert(predicate: => Boolean) =  
    if (assertionsEnabled && !predicate)  
        throw new AssertionError

现在你可以在需要断言的属性里省略空的参数了。使用byNameAssert的结果看上去就好象使用了内建控制结构：

byNameAssert(5 > 3)

传名类型中，空的参数列表()被省略，它仅在参数中被允许。没有什么传名变量或传名字段这样的东西。

现在，你或许想知道为什么你不能简化myAssert的编写，使用陈旧的Boolean作为它参数的类型，如：

def boolAssert(predicate: Boolean) =  
    if (assertionsEnabled && !predicate)  
        throw new AssertionError

当然这种格式同样合法，并且使用这个版本boolAssert的代码看上去仍然与前面的一样：

boolAssert(5 > 3)

虽然如此，这两种方式之间存在一个非常重要的差别须指出。因为boolAssert的参数类型是Boolean，在boolAssert(5 > 3)里括号中的表达式先于boolAssert的调用被评估。表达式5 > 3产生true，被传给boolAssert。相对的，因为byNameAssert的predicate参数的类型是=> Boolean，byNameAssert(5 > 3)里括号中的表达式不是先于byNameAssert的调用被评估的。而是代之以先创建一个函数值，其apply方法将评估5 > 3，而这个函数值将被传递给byNameAssert。

因此这两种方式之间的差别，在于如果断言被禁用，你会看到boolAssert括号里的表达式的某些副作用，而byNameAssert却没有。例如，如果断言被禁用，boolAssert的例子里尝试对x / 0 == 0的断言将产生一个异常：

scala> var assertionsEnabled = false 
assertionsEnabled: Boolean = false 
scala> boolAssert(x / 0 == 0)  
java.lang.ArithmeticException: / by zero  
 at .< init>(< console>:8)  
 at .< clinit>(< console>)  
 at RequestResult$.< init>(< console>:3)  
 at RequestResult$.< clinit>(< console>)...