面向值（value-oriented ）编程有很多优势，特别是用在与函数式编程结构相结合。这种风格强调值的转换（译注：由一个不变的值生成另一个不变的值）而非状态的改变，生成的代码是指称透明的(referentially transparent)，提供了更强的不变型(invariants)，因此容易实现。Case类(也被翻译为样本类)，模式匹配，解构绑定(destructuring bindings)，类型推断，轻量级的闭包和方法创建语法都是这一类的工具。
### Case类模拟代数数据类型
Case类可实现代数数据类型(ADT)编码：它们对大量的数据结构进行建模时有用，用强不变类型(invariants)提供了简洁的代码。尤其在结合模式匹配情况下。模式匹配实现了全面解析提供更强大的静态保护。 (译注：ADTs是Algebraic Data Type代数数据类型的缩写，关于这个概念见我的另一篇[博客](http://hongjiang.info/scala-case-class-and-algebraic-data-type/))
下面是用case类模拟代数数据类型的模式
~~~
sealed trait Tree[T]
case class Node[T](left: Tree[T], right: Tree[T]) extends Tree[T]
case class Leaf[T](value: T) extends Tree[T]
~~~
类型 Tree[T] 有两个构造函器：Node和Leaf。定义类型为sealed(封闭类)允许编译器进行彻底的分析(这是针对模式匹配的，参考Programming in Scala)因为构造器将不能从外部源文件中添加。
与模式匹配一同，这个建模使得代码简洁并且显然是正确的(obviously correct)
~~~
def findMin[T <: Ordered[T]](tree: Tree[T]) = tree match {
case Node(left, right) => Seq(findMin(left), findMin(right)).min
case Leaf(value) => value
}
~~~
尽管一些递归结构，如树的组成是典型的ADTs(代数数据类型)应用，它们的用处领域更大。 disjoint,unions特别容易的用ADTs建模；这些频繁发生在状态机上(state machines)。
### Options
Option类型是一个容器，空(None)或满(Some(value))二选一。它提供了使用null的另一种安全选择，应该尽可能的替代null。它是一个集合(最多只有一个元素)并用集合操所修饰，尽量用Option。
用
~~~
var username: Option[String] = None
...
username = Some("foobar")
~~~
代替
~~~
var username: String = null
...
username = "foobar"
~~~
因为前者更安全：Option类型静态地强制username必须对空(emptyness)做检测。
对一个Option值做条件判断应该用foreach
~~~
if (opt.isDefined)
operate(opt.get)
~~~
上面的代码应该用下面的方式替代：
~~~
opt foreach { value =>
operate(value)}
~~~
风格可能看起来有些古怪，但更安全，更简洁。如果两种情况都有(Option的None或Some)，用模式匹配
~~~
opt match {
case Some(value) => operate(value)
case None => defaultAction()
}
~~~
但如果缺少的是缺省值，用getOrElse方法：
~~~
operate(opt getOrElse defaultValue)
~~~
不要过度使用Option： 如果有一个明确的缺省值——一个[*Null对象*](http://en.wikipedia.org/wiki/Null_Object_pattern)——直接用Null而不必用Option
Option还有一个方便的构造器用于包装空值(nullable value)
~~~
Option(getClass.getResourceAsStream("foo"))
~~~
得到一个 Option[InputStream] 假定空值(None)时getResourceAsStream会返回null。
### 模式匹配
模式匹配(x match { …) 在良好的Scala代码中无处不在：用于合并条件执行、解构(destructuring) 、在构造中造型。使用好模式匹配可以增加程序的明晰度和安全性。
使用模式匹配实现类型转换：
~~~
obj match {
case str: String => ...
case addr: SocketAddress => ...
~~~
模式匹配在和解构(destructuring)联合使用时效果最好（例如你要匹配case类）；下面的写法
~~~
animal match {
case dog: Dog => "dog (%s)".format(dog.breed)
case _ => animal.species
}
~~~
应该被替代为：
~~~
animal match {
case Dog(breed) => "dog (%s)".format(breed)
case other => other.species
}
~~~
写[自定义的抽取器](http://www.scala-lang.org/node/112) (extractor)时必须有双重构造器(译注：成对出现的apply方法与unapply方法)，否则可能是不适合的。
当默认的方法更有意义时，对条件执行不要用模式匹配。集合库的方法通常返回Options，避免：
~~~
val x = list match {
case head :: _ => head
case Nil => default
}
~~~
因为
~~~
val x = list.headOption getOrElse default
~~~
更短并且更能表达目的。
### 偏函数
Scala提供了定义PartialFunction的语法简写：
~~~
val pf: PartialFunction[Int, String] = {
case i if i%2 == 0 => "even"
}
~~~
它们也可能和 orElse 组合:
~~~
val tf: (Int => String) = pf orElse { case _ => "odd"}
tf(1) == "odd"
tf(2) == "even"
~~~
偏函数出现在很多场景，并以PartialFunction有效地编码 ，例如 方法参数：
~~~
trait Publisher[T] {
def subscribe(f: PartialFunction[T, Unit])
}
val publisher: Publisher[Int] = ..
publisher.subscribe {
case i if isPrime(i) => println("found prime", i)
case i if i%2 == 0 => count += 2
/* ignore the rest */
}
~~~
或在返回一个Option的情况下：
~~~
// Attempt to classify the the throwable for logging.
type Classifier = Throwable => Option[java.util.logging.Level]
~~~
可以更好的用PartialFunction表达
~~~
type Classifier = PartialFunction[Throwable, java.util.Logging.Level]
~~~
因为它提供了更好的可组合性：
~~~
val classifier1: Classifier
val classifier2: Classifier
val classifier = classifier1 orElse classifier2 orElse { _ => java.util.Logging.Level.FINEST }
~~~
### 解构绑定
解构绑定与模式匹配有关。它们用了相同的机制，但解构绑定可应用在当匹配只有一种选项的时候 (以免你接受异常的可能)。解构绑定特别适用于元组(tuple)和样本类(case class).
~~~
val tuple = ('a', 1)
val (char, digit) = tuple
val tweet = Tweet("just tweeting", Time.now)
val Tweet(text, timestamp) = tweet
~~~
### 惰性赋值
当使用lazy修饰一个val成员时，其赋值情况是在需要时才赋值的(by need)，因为Scala中成员与方法是等价的（除了private[this]成员）
~~~
lazy val field = computation()
~~~
相当于下面的简写:
~~~
var _theField = None
def field = if (_theField.isDefined) _theField.get else {
_theField = Some(computation())
_theField.get
}
~~~
也就是说，它在需要时计算结果并会记住结果，在要达到这种目的时使用lazy成员；但当语意上需要惰性赋值时(by semantics)，要避免使用惰性赋值，这种情况下，最好显式赋值因为它使得成本模型是明确的，并且副作用被严格的控制。
Lazy成员是线程安全的。
### 传名调用
方法参数可以指定为传名参数 (by-name) 意味着参数不是绑定到一个值，而是一个可能需要反复进行的计算。这一特性需要小心使用； 期待传值(by-value)语法的调用者会感到惊讶。这一特性的动机是构造语法自然的 DSLs——使新的控制结构可以看起来更像本地语言特征。
只在下面的控制结构中使用传名调用, 调用者明显传递的是一段代码块(block)而非一个确定的计算结果。传名参数必须放在参数列表的最后一位。当使用传名调用时，确保方法名称让调用者明显感知到方法参数是传名参数。
当你想要一个值被计算多次，特别是这个计算会引起副作用时，使用显式函数：
~~~
class SSLConnector(mkEngine: () => SSLEngine)
~~~
这样意图很明确，调用者不会感到惊奇。
### `flatMap`
flatMap——结合了map 和 flatten —— 的使用要特别小心，它有着难以琢磨的威力和强大的实用性。类似它的兄弟 map，它也是经常在非传统的集合中使用的，例如 Future , Option。它的行为由它的（函数）签名揭示；对于一些容器 Container[A]
~~~
flatMap[B](f: A => Container[B]): Container[B]
~~~
flatMap对集合中的每个元素调用了 函数 f 产生一个新的集合，将它们全部 flatten 后放入结果中。例如，获取两个字符的字符串的所有排列，相同的字符不能出现两次
~~~
val chars = 'a' to 'z'
val perms = chars flatMap { a =>
chars flatMap { b =>
if (a != b) Seq("%c%c".format(a, b))
else Seq()
}
}
~~~
等价于下面这段更简洁的 for-comprehension （基本就是针对上面的语法糖）
~~~
val perms = for {
a <- chars
b <- chars
if a != b
} yield "%c%c".format(a, b)
~~~
`flatMap`在处理Options常常很有用—— 它将多个options链合并为一个，
~~~
val host: Option[String] = ..
val port: Option[Int] = ..
val addr: Option[InetSocketAddress] =
host flatMap { h =>
port map { p =>
new InetSocketAddress(h, p)
}
}
~~~
也可以使用更简洁的for来实现：
~~~
val addr: Option[InetSocketAddress] = for {
h <- host
p <- port
} yield new InetSocketAddress(h, p)
~~~
对flatMap在在Futures中的使用[futures一节](http://twitter.github.io/effectivescala/index-cn.html#Twitter's%20standard%20libraries-Futures)中有讨论。
