头等函数

Scala的函数是头等函数(first-class function)。你不仅可以定义和调用函数，还可以把它们写成匿名的字面量(literal)，并把它们作为值传递。
函数字面量被编译进类，并在运行期实例化为函数值(function value)。什么意思呢？函数的本质是类的实例。函数是一些特质的集合，任何函数值都是某个扩展了scala包的若干FunctionN特质之一的类的实例，如Function0是没有参数的函数，Function1是有一个参数的函数等等。每个FunctionN特质有一个apply方法用来调用函数。
因此，函数字面量和函数值的区别在于函数字面量存在于源代码，而函数值作为对象存在于运行期。这个区别很想类（源代码）和对象（运行期）之间的关系。

说明：
当你调用一个对象时就行在调用一个函数。

scala> object addOne extends Function1[Int, Int] {
     |   def apply(m: Int): Int = m+1
     | }
defined object addOne

scala> addOne(1)
res12: Int = 2

//类也可以扩展Function，这些类的实例可以使用()调用
scala> class AddOne extends Function1[Int, Int] {
     |   def apply(m: Int): Int = m + 1
     | }
defined class AddOne

scala> val plusOne = new AddOne()
plusOne: AddOne = <function1>

scala> plusOne(1)
res0: Int = 2

//可以使用更直观快捷的extends (Int => Int)代替extends Function1[Int, Int]
class AddOne extends (Int => Int) {
  def apply(m: Int): Int = m + 1
}

这个特质定义了apply语法糖，这样有助于统一对象和函数式编程的二重性。

占位符简化

使用匿名的函数字面量作为另一个函数的参数传入，可以使用占位符_进行简化。以下是几个简化版本：

//高阶函数
scala> def hf(f:String => Unit) = f("higher")
hf: (f: String => Unit)Unit

scala> hf(s=>println(s)) // 第1个简化版本
higher

//这里使用单个下划线替换整个参数列表
scala> hf(println(_)) // 第2个简化版本
higher

scala> hf(println _) // 第3个简化版本
higher

scala> hf(println) // 第4个简化版本
higher

部分应用函数

部分应用函数(partially applied function)，也有翻译为偏应用函数，是一种表达式，你不需要提供函数需要的所有的参数，代之仅提供部分，或者不提供所有参数。
下面给一个例子：

scala> def sum(a: Int, b: Int, c: Int) = a + b + c
sum: (a: Int, b: Int, c: Int)Int

scala> val a = sum _
a: (Int, Int, Int) => Int = <function3>

scala> a(1, 2, 3)
res12: Int = 6

scala> a.apply(1, 2, 3)
res13: Int = 6

上面代码中，Scala编译器以部分应用函数表达式，sum _，实例化一个带3个缺失整数参数的函数值，并把这个新的函数值的索引赋给变量a。
实际发生的情况是这样的：名为a的变量指向一个函数值对象。这个函数值是由Scala编译器依照部分应用函数表达式sum _，自动产生的类的一个实例。编译器产生的类有一个apply方法带有3个参数。之所以带3个参数是因为sum _表达式缺少的参数数量是3。
Scala编译器根据表达式sum _自动产生的类里的apply方法，简单地把这3个缺失的参数传到sum，并返回结果。

这种下划线代表全部参数列表的表达式的另一个用途，就是可以将def定义的函数转换为函数值。通过在函数名称后加下划线的方式，把方法或嵌套函数包装在函数值中。

偏函数

偏函数(partially function)源自于函数未被应用于它所有的参数。在sum _的例子里，它没有应用于任何参数，可以看做是一种偏函数。不过还可以通过提供某些但不是全部需要的参数表达一个偏函数。
如：

scala> val b = sum(1, _:Int, 3)
b: Int => Int = <function1>

scala> b(2)
res14: Int = 6

scala> b(5)
res15: Int = 9

这里提供了第一个和最后一个参数给sum，但中间参数缺失。因为仅有一个参数缺失，Scala编译器会产生一个新的函数类，其apply方法带有一个参数。

闭包

依照函数字面量在运行时创建的函数值(对象)被称为闭包(closure)。该名字源自于通过捕获自由变量的绑定，从而对函数字面量执行的“关闭”行为。
不带自由变量的函数字面量，如(x: Int) => x + 1，被称为封闭项(closed term)。因此依照这个函数字面量在运行时创建的函数值严格意义上不是闭包，因为(x: Int) => x + 1在编写的时候就已经封闭了。但任何带有自由变量的函数字面量，如(x: Int) => x + more，都是开放项(open term)。因此，任何以(x: Int) => x + more为模板再运行期创建的函数值将必须捕获对自由变量more的绑定。因此得到的函数值将包含指向捕获的more变量的索引。又由于函数值是关闭这个开放项(x: Int) => x + more的行为的最终产物，因此被称为闭包。

至于闭包的用途和作用，我现在还不能很透彻的理解其用意，待到之后学习积累了，再作具体介绍。

尾递归

在函数中最后一个动作是调用函数自己的行为，称为尾递归(tail recursive)。Scala编译器检测到尾递归就用新值更新函数参数，然后把它替换成一个回到函数开头的跳转。这种编译器的优化可以保证你使用更加优美简明的递归方案，还无须付出任何运行期开销。

尾递归函数追踪

尾递归函数将不会为每个调用创建新的堆栈结构；所有的调用将在一个结构内执行。这可能会让检查程序的堆栈跟踪信息并失败的程序员感到惊奇。

scala> def boom(x: Int): Int = {
     |   if(x == 0) throw new Exception("boom!")
     |   else boom(x-1) + 1
     | }
boom: (x: Int)Int

scala> boom(3)
java.lang.Exception: boom!
  at .boom(<console>:8)
  at .boom(<console>:9)
  at .boom(<console>:9)
  at .boom(<console>:9)
  ... 33 elided

上面这个函数不是尾递归，因为递归调用之后执行了递增操作，这里可以看到调用堆栈的信息。

scala> def bang(x: Int): Int = {
     |   if(x == 0) throw new Exception("bang!")
     |   else bang(x-1)
     | }
bang: (x: Int)Int

scala> bang(5)
java.lang.Exception: bang!
  at .bang(<console>:8)
  ... 33 elided

这就是一个尾递归的形式了，我们仅看到bang的一个堆栈结构。

Tips：如果你认为你会在看到堆栈跟踪时被尾递归调用优化搞糊涂，你可以用开关项关掉它：将-g:notailcalls参数传给scala的shell或者scalac编译器。

尾递归局限

尾递归优化限定了方法或嵌套函数必须在最后一个操作调用本身，而不是转到某个函数值或者什么其他的中间函数的情况。所以使用间接递归调用或者最后调用的是一个函数值都不能获得尾递归优化。

转载请注明作者Jason Ding及其出处
GitCafe博客主页(http://jasonding1354.gitcafe.io/)
Github博客主页(http://jasonding1354.github.io/)
CSDN博客(http://blog.csdn.net/jasonding1354)
简书主页(http://www.jianshu.com/users/2bd9b48f6ea8/latest_articles)
百度搜索jasonding1354进入我的博客主页