函数式编程

函数式编程

面向值（value-oriented ）编程有很多优势，特别是用在与函数式编程结构相结合。这种风格强调值的转换（译注：由一个不变的值生成另一个不变的值）而非状态的改变，生成的代码是指称透明的(referentially transparent)，提供了更强的不变型(invariants)，因此容易实现。Case类(也被翻译为样本类)，模式匹配，解构绑定(destructuring bindings)，类型推断，轻量级的闭包和方法创建语法都是这一类的工具。

Case类模拟代数数据类型

Case类可实现代数数据类型(ADT)编码：它们对大量的数据结构进行建模时有用，用强不变类型(invariants)提供了简洁的代码。尤其在结合模式匹配情况下。模式匹配实现了全面解析提供更强大的静态保护。 (译注：ADTs是Algebraic Data Type代数数据类型的缩写，关于这个概念见我的另一篇博客)

下面是用case类模拟代数数据类型的模式

1. sealed trait Tree[T]
2. case class Node[T](left: Tree[T], right: Tree[T]) extends Tree[T]
3. case class Leaf[T](value: T) extends Tree[T]

类型 Tree[T] 有两个构造函器：Node和Leaf。定义类型为sealed(封闭类)允许编译器进行彻底的分析(这是针对模式匹配的，参考Programming in Scala)因为构造器将不能从外部源文件中添加。

与模式匹配一同，这个建模使得代码简洁并且显然是正确的(obviously correct)

1. def findMin[T <: Ordered[T]](tree: Tree[T]) = tree match {
2. case Node(left, right) => Seq(findMin(left), findMin(right)).min
3. case Leaf(value) => value
4. }

尽管一些递归结构，如树的组成是典型的ADTs(代数数据类型)应用，它们的用处领域更大。 disjoint,unions特别容易的用ADTs建模；这些频繁发生在状态机上(state machines)。

Options

Option类型是一个容器，空(None)或满(Some(value))二选一。它提供了使用null的另一种安全选择，应该尽可能的替代null。它是一个集合(最多只有一个元素)并用集合操所修饰，尽量用Option。

用

1. var username: Option[String] = None
2. ...
3. username = Some("foobar")

代替

1. var username: String = null
2. ...
3. username = "foobar"

因为前者更安全：Option类型静态地强制username必须对空(emptyness)做检测。

对一个Option值做条件判断应该用foreach

1. if (opt.isDefined)
2. operate(opt.get)

上面的代码应该用下面的方式替代：

1. opt foreach { value =>
2. operate(value)}

风格可能看起来有些古怪，但更安全，更简洁。如果两种情况都有(Option的None或Some)，用模式匹配

1. opt match {
2. case Some(value) => operate(value)
3. case None => defaultAction()
4. }

但如果缺少的是缺省值，用getOrElse方法：

1. operate(opt getOrElse defaultValue)

不要过度使用Option：如果有一个明确的缺省值——一个Null对象——直接用Null而不必用Option

Option还有一个方便的构造器用于包装空值(nullable value)

1. Option(getClass.getResourceAsStream("foo"))

得到一个 Option[InputStream] 假定空值(None)时getResourceAsStream会返回null。

模式匹配

模式匹配(x match { …) 在良好的Scala代码中无处不在：用于合并条件执行、解构(destructuring) 、在构造中造型。使用好模式匹配可以增加程序的明晰度和安全性。

使用模式匹配实现类型转换：

1. obj match {
2. case str: String => ...
3. case addr: SocketAddress => ...

模式匹配在和解构(destructuring)联合使用时效果最好（例如你要匹配case类）；下面的写法

1. animal match {
2. case dog: Dog => "dog (%s)".format(dog.breed)
3. case _ => animal.species
4. }

应该被替代为：

1. animal match {
2. case Dog(breed) => "dog (%s)".format(breed)
3. case other => other.species
4. }

写自定义的抽取器 (extractor)时必须有双重构造器(译注：成对出现的apply方法与unapply方法)，否则可能是不适合的。

当默认的方法更有意义时，对条件执行不要用模式匹配。集合库的方法通常返回Options，避免：

1. val x = list match {
2. case head :: _ => head
3. case Nil => default
4. }

因为

1. val x = list.headOption getOrElse default

更短并且更能表达目的。

偏函数

Scala提供了定义PartialFunction的语法简写：

1. val pf: PartialFunction[Int, String] = {
2. case i if i%2 == 0 => "even"
3. }

它们也可能和 orElse 组合:

1. val tf: (Int => String) = pf orElse { case _ => "odd"}

3. tf(1) == "odd"
4. tf(2) == "even"

偏函数出现在很多场景，并以PartialFunction有效地编码，例如方法参数：

1. trait Publisher[T] {
2. def subscribe(f: PartialFunction[T, Unit])
3. }

5. val publisher: Publisher[Int] = ..
6. publisher.subscribe {
7. case i if isPrime(i) => println("found prime", i)
8. case i if i%2 == 0 => count += 2
9. /* ignore the rest */
10. }

或在返回一个Option的情况下：

1. // Attempt to classify the the throwable for logging.
2. type Classifier = Throwable => Option[java.util.logging.Level]

可以更好的用PartialFunction表达

1. type Classifier = PartialFunction[Throwable, java.util.Logging.Level]

因为它提供了更好的可组合性：

1. val classifier1: Classifier
2. val classifier2: Classifier

4. val classifier = classifier1 orElse classifier2 orElse { _ => java.util.Logging.Level.FINEST }

解构绑定

解构绑定与模式匹配有关。它们用了相同的机制，但解构绑定可应用在当匹配只有一种选项的时候 (以免你接受异常的可能)。解构绑定特别适用于元组(tuple)和样本类(case class).

1. val tuple = ('a', 1)
2. val (char, digit) = tuple

4. val tweet = Tweet("just tweeting", Time.now)
5. val Tweet(text, timestamp) = tweet

当使用lazy修饰一个val成员时，其赋值情况是在需要时才赋值的(by need)，因为Scala中成员与方法是等价的（除了private[this]成员）

1. lazy val field = computation()

相当于下面的简写:

1. var _theField = None
2. def field = if (_theField.isDefined) _theField.get else {
3. _theField = Some(computation())
4. _theField.get
5. }

也就是说，它在需要时计算结果并会记住结果，在要达到这种目的时使用lazy成员；但当语意上需要惰性赋值时(by semantics)，要避免使用惰性赋值，这种情况下，最好显式赋值因为它使得成本模型是明确的，并且副作用被严格的控制。

Lazy成员是线程安全的。

传名调用

方法参数可以指定为传名参数 (by-name) 意味着参数不是绑定到一个值，而是一个可能需要反复进行的计算。这一特性需要小心使用；期待传值(by-value)语法的调用者会感到惊讶。这一特性的动机是构造语法自然的 DSLs——使新的控制结构可以看起来更像本地语言特征。

只在下面的控制结构中使用传名调用, 调用者明显传递的是一段代码块(block)而非一个确定的计算结果。传名参数必须放在参数列表的最后一位。当使用传名调用时，确保方法名称让调用者明显感知到方法参数是传名参数。

当你想要一个值被计算多次，特别是这个计算会引起副作用时，使用显式函数：

1. class SSLConnector(mkEngine: () => SSLEngine)

这样意图很明确，调用者不会感到惊奇。

flatMap

flatMap——结合了map 和 flatten —— 的使用要特别小心，它有着难以琢磨的威力和强大的实用性。类似它的兄弟 map，它也是经常在非传统的集合中使用的，例如 Future , Option。它的行为由它的（函数）签名揭示；对于一些容器 Container[A]

1. flatMap[B](f: A => Container[B]): Container[B]

flatMap对集合中的每个元素调用了函数 f 产生一个新的集合，将它们全部 flatten 后放入结果中。例如，获取两个字符的字符串的所有排列，相同的字符不能出现两次

1. val chars = 'a' to 'z'
2. val perms = chars flatMap { a =>
3. chars flatMap { b =>
4. if (a != b) Seq("%c%c".format(a, b))
5. else Seq()
6. }
7. }

等价于下面这段更简洁的 for-comprehension （基本就是针对上面的语法糖）

1. val perms = for {
2. a <- chars
3. b <- chars
4. if a != b
5. } yield "%c%c".format(a, b)

flatMap在处理Options常常很有用—— 它将多个options链合并为一个，

1. val host: Option[String] = ..
2. val port: Option[Int] = ..

4. val addr: Option[InetSocketAddress] =
5. host flatMap { h =>
6. port map { p =>
7. new InetSocketAddress(h, p)
8. }
9. }

也可以使用更简洁的for来实现：

1. val addr: Option[InetSocketAddress] = for {
2. h <- host
3. p <- port
4. } yield new InetSocketAddress(h, p)

对flatMap在在Futures中的使用[futures一节]中有讨论。