Scala 编程

• 1: Scala 精要
• 1.1: Case Class
• 1.2: 类型系统
• 1.3: 函数式-基础
• 1.4: 函数式-用例
• 1.5: Future-基础
• 1.6: Future-用例
• 1.7: Future-集合
• 1.8: Future-Promise
• 1.9: Implicits-基础
• 1.10: Implicits-进阶
• 1.11: Trait-基础
• 1.12: Trait-用例
• 1.13: Try
• 1.14: Type-用例
• 1.15: Type-进阶
• 1.16: Primitive
• 1.17: Numbers
• 1.18: String
• 1.19: Control
• 1.20: Pattern Match
• 1.21: Class Object: 基础
• 1.22: Class Object: 类
• 1.23: Class Object: 方法
• 1.24: Class Object: 对象
• 1.25: 函数式对象
• 1.26: 整体类层级
• 1.27: 组合继承
• 1.28: Package
• 1.29: SBT
• 1.30: Predef
• 1.31: I/O
• 1.32: 保留字
• 1.33: Exception
• 1.34: Inject Type
• 1.35: Type Class
• 1.36: Map Flatmap
• 1.37: 泛型型变
• 1.38: 常见问题
• 1.39: 占位符
• 1.40: 多变量赋值
• 1.41: 构造器
• 1.42: 函数式入门
• 1.43: Monoid
• 1.44: 函数式与类型类
• 1.45: 异步编程
• 1.46: 战略Scala风格
• 2: Scala 函数式
• 2.1: CH00-精要
• 2.2: CH01-定义
• 2.3: CH02-函数
• 2.4: CH03-数据
• 2.5: CH04-异常

1 - Scala 精要

1.1 - Case Class

下面会用到的 case 类实例：

case class Person(lastname: String, firstname: String, birthYear: Int)

基本特性

case 类与普通类的最大区别在于，编译器会为 case 类添加更多的额外特性。

• 创建一个类和它的伴生对象

• 创建一个名为apply的工厂方法。因此可以在创建实例时省略掉new关键字：

  val p = new Person("Lacava", "Alessandro", 1976)
  val p = Person("Lacava", "Alessandro", 1976)
  

• 为参数列表中的所有参数添加val前缀，表示这些参数作为类的不可变成员，因此你会得到所有这个成员的访问器方法，而没有修改器方法：

  val lastname = p.lastname
  p.lastname = "Brown"		// 编译失败
  

• 为hashCode、equals、toString方法添加原生实现。因为==在 Scala 中代表equals，因此 case 类实例之间总是以结构的方式进行比较，即比较数据而不是比较引用：

  val p_1 = Person("Brown", "John", 1969)
  val p_2 = Person("Lacava", "Alessandro", 1976)
  
  p == p_1 // false
  p == p_2 // true
  

• 生成一个copy方法，使用现有的实例并接收一些新的字段值来创建一个新的实例：

  val p_3 = p.copy(firstname = "Michele", birthYear = 1972)
  

• 最重要的特性，实现一个 unapply 方法。因此，case 类可以支持模式匹配。这在定义 ADT 时尤为重要。unapply方法就是一个析构器。

• 当不需要参数列表时，可以定义为一个case object

常用其他特性

• 创建一个函数，根据提供的参数创建一个 case 类的实例：

  val personCreator: (String, String, Int) => Person = Person.apply _
  personCreator("Brown", "John", 1969)	// Person(Brown,John,1969)
  

• 如果需要将上面的函数柯里化，分多步提供参数来创建一个实例：

  val curriedPerson: String => String => Int => Person = Person.curried
  
  val lacavaBuilder: String => Int => Person = curriedPerson("Lacava")
  
  val me = lacavaBuilder("Alessandro")(1976)
  val myBrother = lacavaBuilder("Michele")(1972)
  

• 通过一个元组来创建实例：

  val tupledPerson: ((String, String, Int)) => Person = Person.tupled
  
  val meAsTuple: (String, String, Int) = ("Lacava", "Alessandro", 1976)
  
  val meAsPersonAgain: Person = tupledPerson(meAsTuple)
  

• 将一个实例转换成一个由其参数构造的元组的Option：

  val toOptionOfTuple: Person => Option[(String, String, Int)] = Person.unapply _
  
  val x: Option[(String, String, Int)] = toOptionOfTuple(p) // Some((Lacava,Alessandro,1976))
  

curried和tupled方法通过伴生对象继承自AbstractFunctionN。N是参数的数量，如果N = 1则并不会得到这两个方法。

以 柯里化 的方式定义 case 类

Scala Case Classes In Depth

其他内建方法

因为所有的 case 类都会扩展Product特质，因此他们会得到如下方法：

• def productArity:Int：获得参数的数量
• def productElement(n:Int):Any：从 0 开始，获得第 n 个参数的值
• def productIterator: Iterator[Any]：获得由所有参数构造的迭代器
• def productPrefix: String：获得派生类中用于toString方法的字符串，这里会返回类名

1.2 - 类型系统

什么是类型系统(type-system)？

A type system is a tractable syntactic method for proving the absence of certain program behaviors by classifying phrases according to the kinds of values the compute. — Benjamin Pierce

一个类型系统是一种易于理解的语法方法，根据所计算的值的类别对短语进行分类，以证明某些程序行为的缺失。

什么是类型(type)？

• 一个类型定义了一个变量可以拥有的一组值，以及一组能够应用于这些值的函数；
• 一组值可以被定义为：
  • 笛卡尔产品类型(Cartesian product Types)，比如 case 类或元组；
  • 总和类型(Sum Types)，比如 Either。
• 类型可以是抽象的和(或)多态的。

为什么需要类型？

• Make illegal states unrepresentable. — Yaron Minsky
  • 使非法状态无法表示
• Where static typing fits, do it every time because it has just fantastic maintenance benefits. — Simon Peyton
  • 在合适的场景总是使用静态类型，因为它具有非常好的维护优势
• Compiler can use Type informations to optimize compiled code.
  • 编译器可以使用类型信息来优化被编译的代码

Scala 的类型系统？

• Scala 是一种同时支持面向对象和函数式的多范式语言
• Scala 拥有强大的静态类型系统
  • 会在编译期检查类型
  • 编译器能够通过推断类型
  • 函数也可以作为类型：A => B

类型的用途？

类型可以用于定义：

• (抽象)类
• 对象
• 特质

Scala 中类型相关的特性？

设计目的

本部分整理至 Martin Odersky 的访谈，原文地址：The Purpose of Scala’s Type System，中文地址：Scala类型系统的目的。

可伸缩性(scalability)

Scala 可以让你不必混用多种专用语言，无论是小型程序还是大型程序，无论是通用用途还是特定应用领域，Scala 都可以胜任。这样，可以避免你在多种语言环境中传递数据。

比如你想跨越数据边界传递数据，像 JDBC，从 Java 像数据库发起一次 SQL 查询，那么发出的查询最终将会是个字符串。这就意味着如果程序中只要有小小的拼写错误，在最终运行时，就会表现为一次非法查询，从而导致一系列相关错误。整个过程中编译器和类型系统不会告诉你那里写错了。

同时，如果仅使用一种语言，则只需要面对一套环境和工具。

可扩展性(extensibility)

“可伸缩性“的维度是”从小到大“。而可扩展性表示从”从通用用途到特定需求“。你可以强化 Scala 语言，使之涵盖你特别关注的领域。

比如数字类型，不同领域有很多不同的数字类型，密码学中的大数、商务人士用的十进制大数、科学家用的复数等等。但如果在语言中加入所有这些可能的类型，则会变得非常笨重。

因此我们可以留给外部库实现，但是又想像使用内置类型的代码一样干净、优雅。为此，你需要语言提供某些扩展机制，是你能够编写用起来不像库的库。

小规模编程中的类型

小规模编程中类型会显得不那么重要。类型的价值分布在一条长长的光谱上，一端表示超级有用，一端表示极度麻烦。通常说它麻烦是因为类型定义可能会太过冗余，要求你手动指定大量类型。有用则是因为，类型能避免运行时错误，能够提供 API 签名文档，能够为代码重构提供安全底线。

Scala 的类型推断，试图尽可能减少类型的麻烦之处。这意味着你编写脚本时并不需要涉及类型，系统会自动进行推断，同时编译器内部仍然会考虑类型。因此仍然能够享受类型检查带来的便利。

单元测试与随心所欲的表达式

仍然需要单元测试来测试你的程序逻辑。但相比动态类型语言，不需要额外对类型进行琐碎的单元测试，因此 Scala 中的单元测试也会精练很多。

另一条针对类型系统的反对意见是：静态类型对表达式限制太严。比如”我想更自由的表达自己，不想要类型系统的条条框框“。我(Martin)认为这种意见不靠谱，第一，Scala 的类型系统实际上很灵活，所以通常它可以让你用非常灵活的模式排列组合，而像 Java 这种类型系统偏弱的语言则难以实现；第二，通过模式匹配，你可以通过非常灵活的方式提取类型信息，甚至根本感觉不到类型信息的损失。

鸭子类型，Java 中的缺失

只要它具备我需要的功能，那么就可以把它当真。比如我需要某种支持关闭操作的资源，我可以以这种方式声明”它必须有 close 方法“，因此我不用关心它是 File、Channel 等等。

要想在 Java 中实现的话，需要定义一个包含该方法的通用接口，然后大家都需要实现这个接口。首先为了实现这一切就会带来大量接口和样板代码。其次，如果有了即成事实之后，你才想到要提个接口，那么几乎不可能做到。如果事先就写了一个类，鉴于这些类早已存在，那么你不改代码就无法加入该接口，除非修改所有客户端代码。所以，这一切都是类型系统强加给你的限制。

而 Scala 中则能表达鸭子类型。你完全可以用 Scala 把某一类型定义为：”任何拥有 close 方法并且该方法返回 Unit 的类型“。同时还可以把类型定义与其他约束结合起来。则可以这样定义类型：任何继承自某个类型，且拥有某某方法签名的类型。还可以这样定义，任何继承自某某类，且拥有某某类型的内部类的类型。从本质上讲，你可以通过定义类型汇总有哪些东西将为你所用，来描绘类型的结构。

既存类型(existential types)

既存类型已有 20 多年历史，它表示，给定某种类型，比如 List，但其内部元素是未知类型。你只知道它是由某种特定类型元素构成的 List，然而并不知道这个特定类型具体是哪种类型。这个概念在 Scala 中可以用既存类型来表达。比如：List[T] forSome {type T}。稍微有点笨重，这也算有意为之。因为事实证明，既存类型往往不大好处理。Scala 有更好的选择，因此不那么需要既存类型，因为 Scala 的类型可以包含其他类型作为内部成员。

归根结底，Scala 只有三种情况需要既存类型。

• Scala 需要能表示 Java 通配符的语义。
• Scala 需要能表示 Java 的 raw 类型，因为有许多库使用类非泛型类型，会出现 raw 类型。如果有一个 Java raw 类型 java.util.List，那么它其实是位置元素类型的 List。
• 既存类型可以把虚拟机中的实现细节反映到上层。类似 Java ，Scala 使用的泛型模型时”擦除类型“。所以在程序运行起来以后，我们就再也找不到类型参数了。之所以要进行擦除，是为了与 Java 的对象模型进行互操作。可是，如果我们需要反射，或者需要表达虚拟机的实现细节时该怎么办呢？我们需要有能力用 Scala 中的某些类型表示虚拟机的行为。

有了既存类型，即使某一类型中的某些方面尚不可知，我们仍然可以操作该类型。

比如，Scala 中的 List，我希望能够描述 head 方法的返回类型。在虚拟机级别，List 类型是 List[T] forSome {type T}。我们不知道 T 是什么。只知道 head 返回 T。既存类型理论告诉我们，该类型是”某些类型 T 中的 T“。也就相当于根类型 Object。那么我们从 head 方法中取回的就是 Object。因此 Scala 中我们要是知道更多信息，就可以直接指定具体类型而不用既存类型的限定规则。但是如果没有更多信息，我们就留着既存类型，让既存类型理论帮我们推断出返回类型。

如果 Java 采用的是”具现化“的泛型类型系统，不支持 raw 类型或通配符类型，那么 Scala 中的既存类型在意义不大，恐怕不会实现既存类型。

Java 与 Scala 中的型变

Java 的型变是定义在使用通配符的代码之处，而 Scala 则是在类型定义之处，当然 Scala 的既存类型一样支持通配符，支持使用 Java 的写法，但并不推荐这么做。

首先，什么是”类型定义之处的型变“？当你定义某个类的类型参数时，例如 List[T]，会有一个问题，如果你给一个苹果列表，那这个列表算不算水果列表呢？显然算，只要苹果是水果的子类型，List[Appke]就是List[Fruit]的子类型，这称为协变。

但某些情况下种种关系不成立，比如我有一个变量，只能用来保存 Apple，那么这个变量就是对类型 Apple 的引用。这个变量并不能当做 Fruit 类型的引用，因为我不能把任意 Fruit 赋值给这个变量，它只能是 Apple。因此可以发现，上述子类型关系在有些情况下适用，有些则不适用。

Scala 中的解决方案是给类型参数添加一个标志。如果 List 中的 T 支持协变，则写作List[+T]。这将意味着任意 List 之间的关系都可以随着其 T 的关系而协变。要想支持协变，必须遵守协变的附加条件。举例来说，只有 List 内容不可变式，List 才能支持协变，否则将会遇到刚才引用变量中类似的问题，而导致无法协变。

Scala 中的机制是这样的：程序员可以声明”我觉得 List 应用支持协变“，即，要求 List 必须遵守子类型关系，然后给 List 的类型参数加上加号标志，仅需一次，List 的所有用户都可以使用。然后编译器会去找出 List 内的所有定义实际上是否兼容协变，确保 List 中不存在导致冲突的成员签名。

相比之下，以 Java 的方式使用通配符，这就意味着库的作者对协变爱莫能助，只能草草定义成 List<T>了事。但接下来如果用户需要协变 List，却不能写作List<Fruit>，而是List<? extends Fruit>。通配符就是这样用的。问题在于这是用户代码啊，用户总不能人人都像设计库的人那么专业吧。此外，这些标注之间，只要有一处不匹配，就会导致类型错误。

Scala 中可以在库中处理型变，让用户感觉不到型变存在，不必手动处理型变。

抽象类型成员

抽象类型与泛型参数看似类似，但拥有更多好处。对于抽象，业界有两套不同的机制：参数化和抽象类型成员。Java 也一样支持两套抽象，只不过 Java 的两套抽象取决于对什么进行抽象。Java 支持抽象方法，但不支持把方法作为参数；Java 不支持抽象字段，但支持把值作为参数；Java 不支持抽象类型成员，但支持把类型作为参数。所以在 Java 中三者均可抽象，但是之间的原理有所区别。

在 Scala 中试图把这些抽象支持的更完备、更正交，即对上述三类成员都采用相同的构造原理。因此，你可以使用抽象字段，也可以使用值参数；可以把方法(函数)作为参数，也可以声明抽象方法；即可以指定类型参数也可以声明抽象类型。至少在原则上，我们可以用同一种面向对象抽象成员的形式，表达全部三类参数。

抽象类型能够更好的处理先前谈到的协变问题。比如，一个 Ainmal 类，其中一个 eat 方法。问题是，如果从 Animal 派生一个类，比如 Cow，那么就能吃某一种食物，比如 Grass。Cow 不可以吃 Fish 之类的其他食物。你希望有办法可以声明 Cow 拥有一个 eat 方法，且该方法只能吃 Grass。实际上，这个需求在 Java 中实现不了，因为你一定会构造出有矛盾的情形，类似之前把 Fruit 复制给 Apple 一样。

Scala 中则可以增加一个类型成员，比如声明一个 SuitableFood 类型，它不定义具体是什么，这就是抽象类型，直接让 Animal 的 eat 方法吃下 SuitableFood 即可。然后在 Cow 中指定其为 Grass 即可。

所以，抽象类型提供了一种机制：先在父类中声明未知类型，稍后再在子类中填上某种已知类型。

你可能会说用参数也可以实现同样功能。确实可以。你可以给 Animal 增加参数，表示能吃的食物。但实践中，当你需要支持许多不同的功能是就会导致参数爆炸。而且通常更要命的问题是参数的边界。

相关概念

类型推断

Scala 拥有类型推断，这表示我们可以省略掉类型注解。

trait Thing
def getThing = new Thing { }

// without Type Ascription, the type is infered to be `Thing`
val infered = getThing

// with Type Ascription
val thing: Thing = getThing

在这些情况下都是可以编译通过的。所以都有哪些地方不能省略类型注解呢：

• 参数
• 公共方法返回值
• 递归或重载方法
• 需要包含类型签名来加快编译速度
• 需要类型签名来使代码更易读

统一的类型系统 — Any、AnyRef、AnyVal

我们之所以称 Scala 的类型系统是统一的，是因为它拥有一个顶层类型 Any。这与 Java 不同，它有一些原始类型(int/long/float/double/byte/char/short/boolean)并非扩展自 Java 中看起来像是顶层类型的 Object。

Any 作为顶层类型，下面有 AnyVal 和 AnyRef 两种子类型。

AnyRef 相当于 Java 中 对象的世界，对应于 Object，作为所有对象的超类。而 AnyVal 表示了 Java 中的 值世界，像 int 或其他 JVM 原始类型。

因此我们可以定义一个接收 Any 类型的方法，同时能够处理 Int 或 String。这对类型系统来说是透明的虽然在虚拟机层 Int 实例会被打包成一个对象。通过查看字节码能够发现：

Method scala/runtime/BoxesRunTime.boxToInteger:(I)Ljava/lang/Integer;

• Conventional types
• Value type classes
• Nonnullable type
• Monad types
• Trait types
• Singlton object types
• Compound types
• Functional Types
• Case classes
• Path-dependent types
• Anonymous types
• Self types
• Type aliases
• Package object
• Generic types
  • 类型擦除问题
• Pattern Match
• Bounded generic types
• Type Variance
• Higher kinded types
• Abstract types
• Existential types
• Implicit types
• View bounded types
• Structural types
• Dotty?

TODO: http://ktoso.github.io/scala-types-of-types/#type-of-an-code-object-code

社区评论

Scala 的语言设计有哪些缺陷？

Scala 中提供了相当多的便利，但这与类型系统的强大无关，仅仅是因为与类型有关。而类型系统的强大之处在于其强大的表现力，能够表示在其它语言中无法表示的事情。

事实上，类型推断是类型系统效率的直接影响因素—它并非那么强大，有些语言拥有完整的类型推断，比如 Haskell。

Scala 中采用局部的基于流的推导，而不是全局式的 HM 推导，导致有些情况不如 Haskell 的推导那么强大。

维基百科：类型推断

为什么有的语言不支持类型推断？

图灵完备：http://www.tuicool.com/articles/rqUjAb

1.3 - 函数式-基础

方法

创建函数最简单的方式就是作为对象的成员，即方法。

本地函数

函数式编程风格的一个主要原则就是：程序应该被解构为若干小的函数块，每块实现一个完备的任务，每块都很小。

但是大量的小块函数会污染程序的命名空间，这时可以私有函数，或者另一种方式，本地函数，即嵌套函数：

import scala.io.Source
object LongLines {
  def processFile(filename:String, width:Int){
    def processLines(line:String){    // 打印超出宽度的行, 引用外层的 width
      if (line.length > width) println(filename + ": " + line)
  }
  val source = Source.fromFile(filename)
  for (line <- source.getLines)
    processLine(line)
  }
}

头等函数

Scala 的函数是头等函数(first-class-function)，不仅可以定义或调用函数，还可以把函数写成匿名字面量，当做值来传递。函数字面量被编译进类，并在运行期实例化为函数值。因此函数字面量与值的区别在于：函数字面量存在于源代码，而函数值作为对象存在于运行期。类似于类(源代码)和对象(运行期)之间的关系。

(x: Int) => x + 1

符号=>指：把左边的东西转换为右边的东西。

函数值是对象，因此可以赋给变量。同时也是函数，可以按照通常的函数调用方式，使用一个括号来调用：

var increase = (x: Int) => x + 1
increase(2)   // 3

函数可以由多条语句构成，由大括号包围，组成一个代码块。当函数执行时，所有的语句都会执行，最后一行作为返回值。

函数字面量的短格式

可以省略函数字面量中的参数类型来进行简化：

someNumber.filter((x) => x > 0)

因为使用这个函数来过滤整数列表someNumber，因此 Scala 可以推断出 x 肯定为整数。这种方式称为目标类型化(target typing)。

某些参数的类型是推断的，可以省略参数的括号：

someNumber.filter(x => x > 0)

占位符语法

只要每个参数在函数字面量中仅出现一次，可以使用占位符_来代替该参数名：

someNumber.filter(_ > 0)

但是有时候把下划线当做参数的占位符，编译器可能无法推断缺失的参数类型：

val f = _ + _

因为上面的filter调用是一个整数列表，编译器可以推断，但这里，编译器无从推断，会编译失败。这时，我们可以为参数提供类型：

val f = (_:Int) + (_:Int)

这里需要注意的是，这里的两个占位符表示的是需要两个参数，而不是一个参数使用两次。

_ + _   (x, y) => x + y
_ * 2     x => x * 2
_.head    xs => xs.head
_ drop _  (xs, n) => xs.drop(n)

在参数较少时，使用这种方式可以使程序更清晰，但是当参数增多，比如foo(_, g(List(_ + 1), _))，则会让程序变得难以理解。

偏应用函数

或称为部分应用函数(Partially applied functions)。

可以使用占位符代替一个参数，也可以代替整个参数列表。比如println(_)，或者println _。

这中下划线方式的使用，实际上定义的是一个部分应用函数。它是一种表达式，不需要提供函数需要的所有参数，可以只提供部分，或者不提供。

比如一个普通的sum函数：

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

当调用函数时，传入任何需要的参数，实际是把函数应用到参数上。

如果通过sum来创建一个部分应用表达式，不需要提供所需要的参数，只需要在sum之后添加一个下划线，使用空格隔开，然后把得到的函数存入变量：

val a = sum _
a : (Int, Int, Int) => Int = <function3>  // function3 类型的实例
a(1,3,4)  // 6

可以看到，a为一个函数。变量a指向一个函数值对象。这个函数值是由 Scala 编译器依照部分应用函数表达式sum _自动产生的类的一个实例。编译器产生的类有一个apply方法，该方法接收 3 个参数。在通过a进行a(1,2,3)调用时，会被翻译成对函数值的apply方法的调用，即apply(1,2,3)。

可以看到function3的源码定义：

/** A function of 3 parameters.
 *
 */
trait Function3[-T1, -T2, -T3, +R] extends AnyRef { self =>
  /** Apply the body of this function to the arguments.
   *  @return   the result of function application.
   */
  def apply(v1: T1, v2: T2, v3: T3): R
  ...
}

偏应用函数实际上是指该函数未被应用到所有的参数，sum的例子是没有应用到任何参数，也可以只应用到部分参数。

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

这时会发现b为一个function1类型的实例，它接收一个参数。

同时，如果定义的是一个省略所有参数的偏应用函数，比如这里的sum，二者在代码的某个位置需要一个相同签名的函数，这时可以省略掉占位符进行简化：

someNumbers.foreach(println _)
someNumbers.foreach(println)

需要注意的是，只有在需要一个函数的地方才可以省略占位符。比如这里，编译器知道foreach需要一个函数。否则会编译错误。比如：val s = sum，必须是：val s = sum _。

闭包

重复参数

可以指定一个函数的最后一个参数是重复的，然后就可以传入可变长度的参数列表：

def echo(args:String*) = 
  for(arg <- args) println(arg)

echo("a")
echo("a", "b")
val seq = Seq("a","b","c")
echo(seq:_*)

尾递归

高阶函数

函数值作为参数的函数称为高阶函数。

减少代码重复

比如我们要实现一个 根据文件名查找文件的程序，首先是文件名以指定字符串结尾的文件名：

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

filesHere这里作为一个工具函数来获取所有文件名列表。

现在如果需要的不只是以指定字符串结尾的方式查找，只要是文件名中包含指定字符串，或者以指定的方式能够匹配指定的字符串，因此我们需要查找的方式是这样的：

def filesMatching(query: String, method ) = 
  for (file <- filesHere; if file.getName.method (query)) yield file

method表示匹配方式，但是 Scala 中不支持传入函数名的方式，因此我们可以传递一个函数值：

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

mathcer接收两个字符串，一个是文件名，一个是需要匹配的字符串，返回一个布尔值表示该文件名与指定的字符串是否匹配。因此，我们可以实现我们的不同匹配方式，而对filesMatching函数进行复用：

def filesEnding(query: String) = filesMatching(query, _.endsWith(_))
def filesContaining(query: String) = filesMatching(query, _.contains(_))
def filesRegex(query: String) = filesMatching(query, _.matches(_))

类似_.endsWith(_)的部分使用了占位符语法，前面已经提到，函数的参数只被使用一次，且参数顺序与使用顺序一致，则可以使用占位符语法简化。其完整的写法实际是：

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

简化后会发现，函数filesMatching的参数中，query已经不再需要了，因为该参数只用于matcher函数，并且已经通过匹配方法传入，因此再次进行简化：

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 filesContains(query:String) = filesMatching(_.contains(query))
  def filesRegex(query:String) = filesMatching(_.matches(query))
}

简化客户端代码

集合 API 提供一些列常用的方法，其中应用了大量的高阶函数，通过将高阶函数作为参数来定义 API，从而使客户端代码更加易于使用。

比如常用的exists、find， 在scala.collection.TraversableLike包中：

def exists(p: A => Boolean): Boolean = {
  var result = false
    breakable {
      for (x <- this)
        if (p(x)) { result = true; break }
    }
    result
}

def find(p: A => Boolean): Option[A] = {
    var result: Option[A] = None
    breakable {
      for (x <- this)
        if (p(x)) { result = Some(x); break }
    }
    result
}

参数p是一个A => Boolean类型的函数，它接收一个参数并放回一个布尔值，用于判断集合中的元素是否满足条件，比如在应用时：

List(1,2,3,-1).exists(_ < 0)

这里同样应用了占位符语法，使整个操作更加简便。

柯里化

柯里化是将函数应用到多个参数列表上。

def plainOldSum(x: Int, y: Int) = x + y   // 普通函数
plainOldSum(1, 2)
def curriedSum(x: Int)(y: Int) = x + y    // 柯里化函数
curriedSum(1)(2)

在调用柯里化函数时，如果没有一次给出所有的参数列表，比如上面的curriedSum，第一次只提供一个参数列表进行调用curriedSum(1)，这时会返回一个函数值(y: Int) => x + y，调用该函数值并提供另一个参数列表，即(y: Int)，得出最后的求和值。

其过程类似于以下面的方式定义函数：

def first(x: Int) = (y: Int) => x + y
val second = first(1) // Int => Int = <function1>
second(2)       // 3

柯里化函数也可以以下面的方式，使用一个占位符语法，来获取中间的函数值，即上面的second函数值：

val onePlus = curriedSum(1)_    // Int => Int = <function1>

调用时提供的占位符_代表第二个参数列表。

同样，可以定义更多个参数列表的柯里化函数，比如：

def multiSum(x: Int)(y: Int)(z: Int) = x + y + z
val second = multiSum(1)_   // Int => (Int => Int) = <function1>
val third = second(2)     // Int => Int = <function1>
third(3)            // 6

自定义控制结构

因为函数可以作为参数值来传递，因此可以使用该特性来定义自己的控制结构，只需要定义接收函数值的方法即可。

比如：

def twice(op: Double => Double, x: Double) = op(op(x))
twice(_ + 1, 5)   // 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) 
)

我们可以利用这种模式来实现不同的控制，比如将withPrintWriter实现为一个日志打印过程或缓存更新过程，而操作部分是一次数据库查询。

这种模式成为借贷模式。这个例子中，控制抽象函数withPrintWriter打开一个资源，即writer，借贷给op函数，当op函数不再需要时又将其关闭。

但是这种模式的使用方式扛起来并不像是一个控制结构，它就是一个函数调用，然而可以通过使用大括号的方式使其更像是真正的控制结构。

但是在使用大括号进行函数调用时只能接收一个参数，比如：

println { "Hello, world!" }
"Hello, world!".substring { 7, 9 }    // error，多个参数必须使用小括号包围参数列表

因此，我们可以将上面的withPrintWriter函数改写为柯里化的方式，每次只接收一个函数，来满足只有一个参数才能使用大括号的要求：

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

然后，下面的调用使withPrintWriter 看起来更像一个控制结构：

withPrintWriter(file) { writer =>
  writer.println(new java.util.Date) 
}

传名参数

但是上面的例子与内建的控制接口，比如if、while并不相似，因为在大括号中需要传入一个参数，这可以通过传名参数实现。

比如定义一个断言函数：

var assertionsEnabled = true

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

然后以下面的方式调用：

myAssert(() => 5 > 3)

或许你更希望使用myAssert(5 > 3)的方式来调用，在创建传名参数时可以使用=>来代替完整的() =>，括号部分实际是函数的参数列表，只不过该函数不接受任何参数，因此省略。

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

myAssert(5 > 3)

一个传名类型，即其参数列表为空()，并进行省略，这样的用法仅仅在作为参数时可行。

但是根据上面的定义方式，其实与def byNameAssert(predicate:Boolean)没有什么差别了。

真正的差别在于，如果是传入的值，这个值必须在调用byNameAssert之前完成计算，如果是传入的函数，则会在调用之后进行计算。

1.4 - 函数式-用例

匿名函数

匿名函数，或函数字面值，可以将它传递给一个方法，或者赋值给一个变量。

比如过滤集合中的偶数，可以将一个匿名函数传递给集合的 filter 方法：

val x = List.range(1, 10)
val evens = x.filter((i: Int) => i % 2 == 0)

这里的匿名函数就是(i: Int) => i % 2 == 0。符号=>可以认为是一个转换器，将集合中的每个整数 i ，通过符号右边的表达式i % 2 == 0转换为一个布尔值，filter 通过这个布尔值判断这个 i 的去留。

因为 Scala 可以推断类型，因此可以省略掉类型：

val evens = x.filter(i => i % 2 == 0)

又因为当一个参数在函数中只出现一次时使用通配符 _ 表示，因此可以省略为：

val evens = x.filter(_ % 2 == 0)

在更为常见的场景中：

x.foreach((i:Int) => println(i))

简略为：

x.foreach((i) => println(i))

进一步简略：

x.foreach(i => println(i))

再次简略：

x.foreach(println(_))

最终，如果由一条语句组成的函数字面量仅接受一个参数，并不需要明确的名字和指定参数，因此最终可以简略为：

x.foreach(println)

像变量一样使用函数

可以向传递一个变量一样传递函数，就像是一个 String、Int 一样。

比如需要将一个数字转换为它的2倍，向上一节一样，将=>当做一个转换器，这时是将一个数字转换为它的2倍，即：

(i: Int) => { i * 2 }

然后将这个函数字面量赋值给一个变量：

val double = (i: Int) => { i * 2 }

变量 double 是一个实例，就像 String、Int 的实例一样，但是它是一个函数的实例，作为一个函数值，然后可以像方法调用一样使用它：

double(2) 	// 4

或者将它传递给一个函数或方法：

list.map(double)

如何声明一个函数

已经见过的方式：

val f = (i: Int) => { i % 2 == 0 }

Scala 编译器能够推断出该方法返回一个布尔值，因此这里省略了函数的返回值。一个包含完整类型的声明会是这样：

val f: (Int) => Boolean = i => { i % 2 == 0 }
val f: Int => Boolean = i => { i % 2 == 0 }
val f: Int => Boolean = i => i % 2 == 0
val f: Int => Boolean = _ % 2 == 0

将函数作为方法的参数

这种需求的处理过程：

1. 定义方法，定义想要接收并作为参数的函数签名
2. 定义一个或多个对应该签名的函数
3. 将需要的函数传入方法

def executeFunction(callback:() => Unit) {
  callback() 
}

签名callback:() => Unit表示该函数不需要参数并返回一个空值。比如：

val sayHello = () => { println("Hello") }
executeFunction(sayHello)

这里，方法中定义的函数名并没有实际意义，仅作为方法的一个参数名，就像一个 Int 常被命名为字母 i 一样，这里可以通用定义为任何形式：

def executeFunction(f:() => Unit) {
  f() 
}

同时，传入的函数必须与签名完全一致，签名通用的语法为：

methodParameterName: (functionParameterType_s) => functionReturnType

更为复杂的函数

函数参数的签名为：接收一个整形数字作为参数并返回一个空值：

def exec(callback: Int => Unit) {
  callback(1) 	// 调用传入的函数
}
val plusOne = (i: Int) => { println(i+1) }
exec(plusOne)

或者接收更多参数的函数：

executeFunction(f:(Int, Int) => Boolean)

或者返回一个集合类型：

exec(f:(String, Int, Double) => Seq[String])

或者接收函数参数并同时接受其他类型的参数：

def executeAndPrint(f:(Int, Int) => Int, x: Int, y: Int) { 
  val result = f(x, y) 
  println(result) 
}

使用闭包

如果需要将函数作为一个参数传递，同时又需要使函数在其声明的作用域引用以存在的变量。比如下面这个例：

class Foo {
  def exec(f:String => Unit, name:String){ f(name) }
}

object ClosureExample extends App{
  var hello = "hello"
  def sayHello(name:String) = { println(s"$hello, $name") }	// 引入闭包变量 hello
  
  val foo = new otherscope.Foo
  foo.exec(sayHello, "Al")
  
  hello = "Hola"			// 修改本地变量 hello
  foo.exec(sayHello, "Lorenzo")
}

Hello, Al
Hola, Lorenzo

在这个例子中，函数 sayHello 在定义时除了声明了一个正式参数 name，同时引用了当前作用域的变量 hello。将 函数 sayHello 作为一个参数传入 exec 方法后，再修改本地变量 hello 的值，sayHello中仍然能够引用到改变后的 hello 的值。这里，Scala 创建了一个闭包。

这里为了简单只只是将 sayHello 传递给了 exec 方法，同样可以将其传递到很远的位置，即多层传递。但是变量并不在 Foo 的作用域或方法 exec 的作用域中，比如在 Foo 中或 exec 中再单独打印 hello 都不会编译通过。

闭包的三个要素：

• 一段代码块可以像值一样传递
• 任何拥有这段代码块的人都可以在任何时间根据需要执行它
• 这段代码块可以在创建它的上下文中引用变量

创建闭包

var votingAge = 18
val isOfVotingAge = (age: Int) => age >= votingAge

现在可以把函数 isOfVotingAge 传递给任意作用域中的函数、方法、对象，同时 votingAge 是可变的，改变它的值同时会引起 isOfVotingAge 函数中对他引用的值的改变。

使用其他数据结构闭包

val fruits = mutable.ArrayBuffer("apple")
val addToBasket = (s: String) => { 
  fruits += s 
  println(fruits.mkString(", ")) 
}

这时，将 addToBasket 函数传递到其他作用域并执行时，都能够修改 fruits 的值。

使用偏应用函数

可以定义一个需要多个参数的函数，提供部分参数并返回一个偏函数，它会携带已获得的参数，最终传递给他剩余需要的参数以完成执行：

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

它本身需要三个参数，当只提供两个参数时，它会返回一个偏函数：

val sum = (a: Int, b: Int, c: Int) => a + b + c
// sum: (Int, Int, Int) => Int = <function3>

val f = sum(1, 2, _: Int)
// f: Int => Int = <function1>

最后给他提供一个参数，完成整个计算：

f(3)
// 6

创建返回函数的函数

可以定义一个返回函数的函数，将它传递给另一个函数，最终提供需要的参数并调用。

这是一个匿名函数：

(s: String) => { prefix + " " + s }

定义一个函数来生成这个函数：

def saySomething(prefix: String) = (s: String) => {
  prefix + " " + s 
}

可以将它赋值给一个变量并通过这个拥有函数值的变量来调用函数：

val sayHello = saySomething("Hello")
sayHello("Alex")

或者更复杂的，根据输入值的不同从而返回不同的函数：

def greeting(language: String) = (name: String) => { 
  language match { 
    case "english" => "Hello, " + name 
    case "spanish" => "Buenos dias, " + name 
  } 
}

创建偏函数

可以创建一个函数，只对所有可能的输入值的一个子集有效(称为偏函数的原因)，或者一组这样的函数，最后通过组合来完成需要的功能。

定义一个偏函数：

val divide = new PartialFunction[Int, Int] { 
  def apply(x: Int) = 42 / x 
  def isDefinedAt(x: Int) = x != 0 	// 仅对部分不等于 0 的整数有效
}

divide.isDefinedAt(1)  					// true
if (divide.isDefinedAt(1)) divide(1)	// 42
divide.isDefinedAt(0)					// false

或者更为常用的模式：

val divide2: PartialFunction[Int, Int] = {
  case d: Int if d != 0 => 42 / d 
}

意思就是，它只能接受 Int 类型参数的一部分(d 不等于 0)进行处理并返回一个 Int 值。

使用 case 的方式仍然能够更第一种方式一样判断它是否能够接受一个值：

divide2.isDefinedAt(0)
divide2.isDefinedAt(1)

同时可以使用 orElse 将多个偏函数组合，andThen 则是将多个偏函数进行链接。

1.5 - Future-基础

介绍：Java 与 Scala 中的并发

Java 通过内存共享和锁来提供并发支持。Scala 中通过不可变状态的转换来实现：Future。虽然 Java 中也提供了 Future，但与 Scala 中的不同。

二者都是通过异步计算来表示结果，但是 Java 中需要使用阻塞的get方法来访问结果，同时可以在调用get之前使用isDone来检查结果是否完成来避免阻塞，但是仍然需要等待结果完成以支持后续使用该结果的计算。

在 Scala 中，无论Future是否完成，都可以对他指定转换过程。每一个转换过程的结果都是一个新的Future，这个新的Future表示通过函数对原始Future转换后得到的结果。计算执行的线程通过一个隐式的*execution context(执行上下文)*来决定。以不可变状态串行转换的方式来描述异步计算，避免共享内存和锁带来的额外开销。

锁机制的弊端

Java 平台中，每个对象都与一个逻辑监视器关联，以控制多线程对数据的访问。使用这种模式时需要指定哪些数据会被多线程共享并将被访问的、控制访问的和共享数据的代码段都标记为synchronized。Java 运行时使用锁的机制来确保同一时间只有一个线程能够进入被锁保护的代码段。以此协调你能够通过多线程来访问数据。

为了兼容性，Scala 提供了 Java 的并发原语。可以在 Scala 中调用方法wait/notify/notifyAll，并且意义与 Java 一致。但是并不提供关键字synchronized，但是预定义了一个方法：

var counter = 0
synchronized {
  // 这里同时只能有一个线程
  counter = counter + 1
}

但是这种模式难于编写可靠的多线程应用。死锁、竟态…

使用 Try 处理异步中的异常

当你调用一个 Scala 方法时，它会在你等待返回结果时执行一个计算，如果结果是一个Future，它表示另一个异步化执行的计算，通常会被一个完全不同的线程执行。在Future上执行的操作都需要一个excution context来提供异步执行的策略，通常可以使用由 Scala 自身提供的全局执行上下文，在 JVM 上，它使用一个线程池。

引入全局执行上下文：

import scala.concurrent.ExecutionContext.Implicits.global
val future = Future { Thread.sleep(10000); 21 + 21 }

当一个Future未完成时，可以调用两个方法：

future.isComplated		// false
future.value			// Option[scala.util.Try[Int]] = None

完成后：

future.isComplated		// true
future.value			// Option[scala.util.Try[Int]] = Some(Success(42))

value方法返回的Option包含一个Try，成功时包含一个类型为 T 的值，失败时包含一个异常，java.lang.Throwable的实例。

Try支持在尝试异步计算前进行同步计算，同时支持一个可能包含异常的计算。

同步计算时可以使用try/catch来确保新城调用方法并捕捉、处理方法抛出的异常。但是异步计算中，发起计算的线程常会移动到其他任务上，然后当计算中抛出异常时，原始的线程不再能通过catch子句来处理异常。因此使用Future进行异步操作时使用Try来处理可能的失败并生成一个值，而不是直接抛出异常。

scala> val fut = Future { Thread.sleep(10000); 21 / 0 } 
fut: scala.concurrent.Future[Int] = ...

scala> fut.value 
res4: Option[scala.util.Try[Int]] = None

// 10s later
scala> fut.value 
res5: Option[scala.util.Try[Int]] = Some(Failure(java.lang.ArithmeticException: / by zero))

Try的定义：

object Try {
  /** 通过传名参数构造一个 Try。
   * 捕获所有 non-fatal 错误并返回一个 `Failure` 对象。
   */
  def apply[T](r: => T): Try[T] =
    try Success(r) catch {				// 常规的 try、catch 调用
      case NonFatal(e) => Failure(e)
    }
}
sealed abstract class Try[+T]
final case class Failure[+T](exception: Throwable) extends Try[T]
final case class Success[+T](value: T) extends Try[T]

Future 操作

map

将传递给map方法的函数作用到原始Future的结果并生成一个新的Future：

val result = fut.map(x => x + 1)

原始Future和map转换可能在两个不同的线程上执行。

for

因为Future声明了一个flatMap方法，因此可以使用for表达式来转换。

val fut1 = Future { Thread.sleep(10000); 21 + 21 }	// Future[Int]
val fut2 = Future { Thread.sleep(10000); 23 + 23 }	// Future[Int]
for { x <- fut1; y <- fut2 } yield x + y			// Future[Int]

因为for表达式是对转换的串行化，如果没有在for之前创建Future并不能达到并行的目的。

for { 
	x <- Future { Thread.sleep(10000); 21 + 21 } 
	y <- Future { Thread.sleep(10000); 23 + 23 } 
} yield x + y		// 需要最少 20s 的时间完成计算

for { x <- fut1; y <- fut2 } yield x + y实际会被转化为fut1.flatMap(x => fut2.map(y => x + y))。

flatMap的定义：将一个函数作用到Future成功时的结果并生成一个新的Future，如果原Future失败，新的Future将会包含同样的异常。

创建 Future

上面的例子是通过Future的apply方法来创建：

def apply[T](body: =>T)(implicit @deprecatedName('execctx) executor: ExecutionContext): Future[T] = impl.Future(body)

body是需要执行的异步计算。

创建一个成功的Future：

Future.successful { 21 + 21 }
// def successful[T](result: T): Future[T] = Promise.successful(result).future
// result 为 Future 的结果

创建一个失败的Future：

Future.failed(new Exception("bummer!"))
// def failed[T](exception: Throwable): Future[T] = Promise.failed(exception).future
// exception 为指定的异常

通过Try创建一个已完成的Future：

import scala.util.{Success,Failure}
Future.fromTry(Success { 21 + 21 })
Future.fromTry(Failure(new Exception("bummer!")))
// def fromTry[T](result: Try[T]): Future[T] = Promise.fromTry(result).future

常用的方式是通过Promise来创建，得到一个被这个Promise控制的Future，当这个Promise完成时对应的Future才会完成：

val pro = Promise[Int]			// Promise[Int]
val fut = pro.future			// Future[Int]
fut.value						// None
pro.success(42)					// 或者 pro.failure(exception)/pro.complete(result: Try[T])
fut.value						// Try[Int]] = Some(Success(42))

或者调用completeWith方法并传入一个新的Future，新的Future一旦完成则用值赋予给这个Priomise。

filter & collect

filter用户验证Future的值，如果满足则保留这个值，如果不满足则会抛出一个NoSuchElementException异常：

val fut = Future { 42 }
val valid = fut.filter(res => res > 0)
valid.value		// Some(Success(42))
val invalid = fut.filter(res => res < 0)
invalid.value	// Some(Failure(java.util.NoSuchElementException: Future.filter predicate is not satisfied))

同时提供了一个withFilter方法，因此可以在for表达式中执行相同的操作：

val valid = for (res <- fut if res > 0) yield res
val invalid = for (res <- fut if res < 0) yield res

collect方法对Future的值进行验证并通过一个操作将其转换。如果传递给collect的偏函数符合Future的值，该Future会返回经过偏函数转换后的值，否则会抛出NoSuchElementException异常：

val valid = fut collect { case res if res > 0 => res + 46 }		// Some(Success(88))
val invalid = fut collect { case res if res < 0 => res + 46 }	// NoSuchElementException

错误处理：failed、fallBackTo、recover、recoverWith

failed

failed方法将一个任何类型的、错误的Future转换为一个成功的Future[Throwable]，这个Throwable即引起错误的异常。

val failure = Future { 42 / 0 }
failure.value			// Some(Failure(java.lang.ArithmeticException: / by zero))
val expectedFailure = failure.failed
expectedFailure.value	// Some(Success(java.lang.ArithmeticException: / by zero))

如果调用failed方法的Future最终是成功的，而调用failed方法返回的Future会以一个NoSuchElementException异常失败。因此，只有当你需要Future失败时，调用failed方法才是适当的：

val success = Future { 42 / 1 }
success.value			// Some(Success(42)), 原本是一个成功的 Future
val unexpectedSuccess = success.failed
unexpectedSuccess.value	// NoSuchElementException, 称为一个失败的 Future

fallBackTo

fallBackTo方法用于提供一个可替换的Future，以便调用该方法的Future失败时作为备用。

val fallback = failure.fallbackTo(success)
fallback.value

如果调用fallBackTo方法的原始Future执行失败，传递给fallBackTo的错误本质上会被忽略。但是如果调用fallBackTo提供的Future也失败了，则会返回最初的错误，即原始Future中的错误：

val failedFallback = failure.fallbackTo( 
	Future { val res = 42; require(res < 0); res } // 这里实际是一个 require 异常
)
failedFallback.value	// Some(Failure(java.lang.ArithmeticException: / by zero))，仍然返回了原始 Future 中的除零异常

recover

recover允许将一个失败的Future转换为一个成功的Future，或者原始Future成功时则不作处理。

val recovered = failedFallback recover { case ex: ArithmeticException => -1 }
recovered.value		// Some(Success(-1)), 捕捉异常并设置成功值，返回新的 Future

如果原始Future成功，recover部分会以相同的值完成：

val unrecovered = fallback recover { case ex: ArithmeticException => -1 }
unrecovered.value	// Some(Success(42))

同时，如果传递给recover的偏函数并不包含原始Future的错误类型，新的Future仍然会以原始Future中的失败完成：

val alsoUnrecovered = failedFallback recover { case ex: IllegalArgumentException => -2 }
alsoUnrecovered.value	// Some(Failure(java.lang.ArithmeticException: / by zero))

recoverWith

recoverWith与recover类似，但是使用的是一个Future值。

val alsoRecovered = failedFallback recoverWith { 
	case ex: ArithmeticException => Future { 42 + 46 } 	// 这是一个 Future
}

其他方面的处理则于recover一致。

transform：对可能性的映射

transfor接收两个转换Future的函数：一个处理原始Future成功的请求，一个处理失败的情况。

val first = success.transform( 
	res => res * -1, 						// 成功
	ex => new Exception("see cause", ex) 	// 失败
)

**注意：**现有的transform并不能将一个成功的Future转换为一个失败的Future，或者反向。只能对成功时的结果进行转换或失败时的异常类型进行转换。

Scala 2.12 版本中提供了一种替代的方式，接收Try => Try的函数：

val firstCase = success.transform { 		// 处理成功的 Future
	case Success(res) => Success(res * -1) 
	case Failure(ex) => Failure(new Exception("see cause", ex)) 
}

val secondCase = failure.transform { 		// 处理失败的 Future
	case Success(res) => Success(res * -1) 
	case Failure(ex) => Failure(new Exception("see cause", ex)) 
}

val nonNegative = failure.transform { 		// 将失败转换为成功
	case Success(res) => Success(res.abs + 1) 
	case Failure(_) => Success(0) 
}

组合 Future：zip、fold、reduce、sequence、traverse

zip

zip方法将两个成功的Future转换为一个新的Future，其值两个Future值的元组。

val zippedSuccess = success zip recovered		// scala.concurrent.Future[(Int, Int)]
zippedSuccess.value								// Some(Success((42,-1)))

如果其中一个失败，zip方法的值会以同样的异常失败：

val zippedFailure = success zip failure
zippedFailure.value		// Some(Failure(java.lang.ArithmeticException: / by zero))

如果两个都失败，结果值会包含最初的异常，即调用zip方法的那个Future的异常。

fold

trait TraversableOnce[+A] extends GenTraversableOnce[A]

可以被贯穿一次或多次的集合的模板特质。它的存在主要用于消除Iterator和Traversable之间的重复代码。包含一系列抽象方法并在Iterator和Traversable..中实现，这些方法贯穿集合中的部分或全部元素并返回根据操作生成的值。

fold方法通过穿过一个TraversableOnce的Future集合来累积值，生成一个Future结果。如果集合中的所有Future都成功了，结果Future会以累积值成功。如果集合中任何一个失败，结果Future就会失败。如果多个Future失败，结果中会包含第一个失败的错误。

val fortyTwo = Future { 21 + 21 }
val fortySix = Future { 23 + 23 }
val futureNums = List(fortyTwo, fortySix)
val folded = Future.fold(futureNums)(0) { 	// (0), 提供一个累积值的初始值
	(acc, num) => acc + num 
}
folded.value								// Some(Success(88))

reduce

reduce方法与fold类似，但是不需要提供初始的默认值，它使用最初的Future的结果作为开始值。

val reduced = Future.reduce(futureNums) { 
	(acc, num) => acc + num 
}
reduced.value	// Some(Success(88))

如果给reduce方法传入一个空的集合，则会以NoSuchElementException异常失败，因为没有初始值。

sequence

sequence方法将一个TraversableOnce的Future集合转换为一个包含TraversableOnce值的Future。比如List[Future[Int]] => Future[List[Int]]:

val futureList = Future.sequence(futureNums)
futureList.value	// Some(Success(List(42, 46)))

traverse

traverse方法将一个包含任意元素类型的TraversableOnce转换为一个TraversableOnce的Future，并且这个序列转换为一个TraversableOnce值的Future。比如，List[Int] => Future[List[Int]]：

val traversed =Future.traverse(List(1, 2, 3)) { i => Future(i) }	// .Future[List[Int]]
traversed.value		// Some(Success(List(1, 2, 3)))

执行副作用：foreach、onComplete、andThen

有时需要在Future完成时执行一些副作用，而不是通过Future生成一个、一些值。

foreach

最基本的foreach方法会在Future成功完成时执行一些副作用。失败时将不会执行：

failure.foreach(ex => println(ex))		// 不会执行
success.foreach(res => println(res))	// 42

因为不带yield的for表达式会被重写为一个foreach执行，因此也可以使用for表达式来实现：

for (res <- failure) println(res)
for (res <- success) println(res)

onComplete

这是Future的一种回调函数，无论Future最终成功或失败，onComplete方法都会执行。它需要被传入一个Try：Success用于处理成功的情况，Failure用于处理失败的情况：

success onComplete { 
	case Success(res) => println(res) 
	case Failure(ex) => println(ex) 
}

andThen

Future并不会保证通过onComplete注册的回调函数的执行顺序。如果需要保证回调函数的执行顺序，可以使用andThen方法代替，它是Future的两一个回调函数。

andThen方法返回一个对原始Future映射(即与原始 Future 同样的方式成功或失败)的新Future，但是当回调完全执行后才会完成。它的功能是，既不影响原始 Future 的结果，又能在原始 Future 完成时执行一些回调。

val newFuture = success andThen { 
	case Success(res) => println(res) 
	case Failure(ex) => println(ex) 
}
42					// 在回调中打印 结果
newFuture.value		// Some(Success(42)), 同时仍然保持了原始 Future 的值

但是需要注意的是，如果传递给andThen的函数如果在执行时引发异常，该异常会传递给后续的回调或者通过结果Future呈现。

2.12 中的新方法

flatten

flatten方法将一个嵌套的Future转换为一个单层的Future，即Future[Future[Int]] =>Future[Int] ：

val nestedFuture = Future { Future { 42 } }		// Future[Future[Int]]
val flattened = nestedFuture.flatten			// Future[Int]

zipWith

zipWith方法实质上是对两个Future执行zip方法，并将结果元组执行一个map调用：

val futNum = Future { 21 + 21 }
val futStr = Future { "ans" + "wer" }
val zipped = futNum zip futStr
val mapped = zipped map { case (num, str) => s"$num is the $str" }

使用zipWith只需要一步：

val fut = futNum.zipWith(futStr) { // Scala 2.12 
	case (num, str) => s"$num is the $str" 
}

transformWith

transformWith支持通过一个Try => Future的函数来转换Future：

val flipped: Future[Int] = success.transformWith { // Scala 2.12 
	case Success(res) => Future { throw new Exception(res.toString) } 
	case Failure(ex) => Future { 21 + 21 } 
}

该方法实质上是对transform方法的重写，它支持生成一个Future而不是生成一个Try。

测试 Future

Future 的作用在于避免阻塞。在很多 JVM 实现上，创建上千个线程之后，线程间的上下文切换对性能的影响达到不能接受的程度。通过避免阻塞，可以繁忙时维持有限的线程数。不过，Scala 支持在需要的时候阻塞Future的结果，通过Await。

val fut = Future { Thread.sleep(10000); 21 + 21 }
val x:Int = Await.result(fut, 15.seconds) 		// <= blocks

然后就可以对其结果进行测试：

import org.scalatest.Matchers._
x should be (42)

或者直接通过特质ScalaFutures提供的阻塞结构来测试。比如futureValue方法，它会阻塞直到Future完成，如果Future失败，则会抛出TestFailedException异常。

import org.scalatest.concurrent.ScalaFutures._
val fut = Future { Thread.sleep(10000); 21 + 21 }
fut.futureValue should be (42)			// <= futureValue 阻塞

或者使用 ScalaTest 3.0 提供的异步测试风格：

import org.scalatest.AsyncFunSpec 
import scala.concurrent.Future

class AddSpec extends AsyncFunSpec {

	def addSoon(addends: Int * ): Future[Int] = Future { addends.sum }

	describe("addSoon") { 
		it("will eventually compute a sum of passed Ints") { 
			val futureSum: Future[Int] = addSoon(1, 2) 
			// You can map assertions onto a Future, then return 
			// the resulting Future[Assertion] to ScalaTest: 
			futureSum map { sum => assert(sum == 3) } 
		}
	}
}

1.6 - Future-用例

在 Akka 中实现事务

因为 Akka 中的ask模式有超时问题，这种方式不易于多重逻辑处理与 Debug，因此可以使send模式与Promise组合的方式来实现与其他 actor 的通信：在当前 actor 中创建Promise，通过send发送给其他 actor 引用，在其他 actor 中完成对Promise的填充，然后在当前 actor 中来处理这个被填充后的Promise - 即处理一个Future。

如果需要同时与多个 actor 通信，拿到所有 actor 的结果 - 即多个由Promise填充后生成的Future，才能完成后续的逻辑处理 - 即事务部分。只需要通过for表达式的方式来实现“所有需要的Future“都已完成。但是多个Future中任何一部分都会引发异常，包括事务部分，因此在最后的结果失败处理(事务回调)中要对所有的错误情况进行处理，比如通知其他的各个 actor 将刚才的操作分别进行回滚(比如买了一个东西，事务失败，重新将这个东西放回库存中，或者同时，将用户账户的余额扣款取消)。

import scala.concurrent.{ Future, Promise }
import scala.concurrent.ExecutionContext.Implicits.global

val fundsPromise:Promise[Funds] = Promise[Funds]
val sharesPromise:Promise[Shares] = Promise[Shares]

buyerActor ! GetFunds(amount, fundsPromise)
sellerActor ! GetShares(numShares, stock, sharesPromise)

val futureFunds = fundsPromise.future
val futureShares = sharesPromise.future

def transact(funds:Funds, shares:Shares):ResultType = {
  // 一些事务操作，比如更新数据库、缓存等
  // 这里也可能引发一些异常
}

val purchase = for{
  funds <- futureFunds
  shares <- futureShares
  // if ... 一些条件等等
} yield transact(funds, shares)

// 通过回调来处理事务结果
purchase onComplete{
  case Success(transcationResult) =>
  	buyerActor ! PutShares(numShares)
  	sellerActor ! PutFunds(amount)
  	// 通知其他系统事务执行成功
  case Failure(err) =>
  	// 分别检查各个操作是否成功，成功则通知其进行对应的回滚操作
  	futureFunds.onSuccess{ case _ =>  buyerActor ! PutFunds(amount) }
  	futureShares onSuccess { case _ => sellerActor ! PutShares(numShares) }
  	// 通知其他系统事务执行失败
}

在处理事务结果部分，如果需要得到值而不是以通知(副作用)的方式，并对事务结果进行检查以执行其他操作(回滚等)，可以使用andThen方法，而不是通过onComplete对调：

val purchaesResult:Future[Result] = purchase andThen{
  case Success(res) => ???
  case Failure(ex) => ???
}
// 然后再响应给客户端或其他后续的处理，而不需要在 onComplete 中编写大量嵌套很深的逻辑
doSomething(purchaesResult)

另一种解决方案是创建一个临时的 actor 来保存状态。

1.7 - Future-集合

**主要解决的问题：**处理Future的集合，使用分组方式避免一次将过多的Future压入执行器队列。有效处理，每个单独Future可能引发的异常，同时不会丢弃Future的结果，对所有的Future结果进行累积并返回。最后抽象为一种清晰易复用的模式提供使用。

Scala、Akka 中的Future并不是 lazy 的，一旦构造会立即执行。而scalaz中为 lazy。Lazy 性质的Future实际是创建一个执行计划，并被最终的调用者执行。这种技术有很多优势，而本文基于标准的Future。

示例需要的所有引入：

import scala.language.higherKinds
import scala.collection.generic._
import scala.concurrent._
import scala.concurrent.duration._
import ExecutionContext.Implicits.global

多次调用返回 Future 的方法

首先是一个返回Future的方法：

trait MyService {
  def doSomething(i: Int) : Future[Unit]
}
class MyServiceImpl extends MyService {
 def doSomething(i: Int) : Future[Unit] = Future { Thread.sleep(500);println(i) }
}

有些场景下需要调用多次：

val svc : MyService = new MyServiceImpl
val someInts : List[Int] = (1 to 20).toList
val result : Unit = someInts.foreach(svc.doSomething _)

然而这会创建一个List[Future[Unit]]，其中包含 20 个会立即执行的Future，20 个还好，如果是成百上千个则难以承受。

程序内部，执行器会将Future存入队列，并使用所有可用的 worker 来执行尽可能多的Future。一次将过多的Future压入队列将会使其他需要执行器的代码进入饥饿状态并引起内存溢出错误。

另一方面，所有svc.doSomething的返回值被丢弃并赋予一个Unit。这里不但没有正确的等待Future完成，而且还把Future分配为Unit，这会扔掉所有可能的异常。

不能将 Future 指派为 Unit

为了避免将Future指派为Unit，可以使用map来替换foreach。同时，需要一种方式来等待所有的Future完成。

val futResult:Future[List[Unit]] = 
  Future.sequence{											// 2
    someInts.map(svc.doSomething _)							// 1
  }
val result: Unit = Await.result(futResult, Duration.Inf)	// 3

1. 使用map将不会丢弃Future的结果
2. 使用Future.sequence将List[Future[Unit]]转换为Future[List[Unit]]
3. 恰当的等待所有Future完成，这时可以安全的丢弃List[Unit]，因为没有抛出任何异常

当svc.doSomething调用过程中抛出异常时会通过Await.result体现。

Future.sequence会等待所有内部的Future完成，一旦完成，外部的Future则会完成。

Future.sequence 源码

控制 Future 的执行流程

val result:Unit = 
  someInts
  	.grouped(3)										// 1
  	.toList
  	.map{ group =>
  	  val innerFutResult: Future[List[Unit]] = 		// 2
  	    Future.sequence {
  		  group.map(svc.doSomething _)
		}
		Await.result(innerFutResult, Duration.Inf)	// 3
    }.flatten										// 4

1. 将someInts每 3 个分成一组
2. 每一组创建一个Future[List[Unit]]
3. 使用Await.result等待每一个内部分组完成
4. 因为将someInts分割成了多个小组，这时需需要使用flatten将整个嵌套的分组展开

这样可以很好的解决一次将大量的Future压入执行器队列，同时使用map也不会丢弃Future的结果。但是有个问题就是这种方式不会返回一个Future结果，因为Await.result的使用使整个执行变成了部分同步阻塞。在实际的异步编程中，这样是不可取的。

返回 Future

为了使结果为Future，下面是新的实现：

val futResult: Future[List[Unit]] = 
  someInts
    .grouped(3)
    .toList
    .foldLeft(Future.successful(List[Unit]())){ (futAccumulator, group) =>	// 1
  	  futAccumulator.flatMap{ accumulator =>								// 2
  		val futInnerResult:Future[List[Unit]] = 
  		  Future.sequence {
  			group.map(svc.doSomething _)
		  }
		futInnerResult.map(innerResult => accumulator ::: innerResult)		// 3
	  }  
	}
val result: Unit = Await.result(futResult, Duration.Inf)

1. 使用foldLeft替换map，这样可以确保一次只处理一个组，然后当每个组完成时，从左到右对每个组进行累积。累计器被初始化为一个已完成的Future.successful(List[Unit]())。
2. 使用Future.flatMap替换Future.map，这里用于展开返回结果的类型为Future[List[Unit]]。如果使用map，返回结果将会是Future[Future[List[Unit]]]。
3. 一旦一个分组完成，将结果进行累积。

现在返回结果已经是一个Future了，但是这种使用模式很常见，但上面的写法难以复用，因此需要简化其复杂性。

简化

这里将会使用 for 表达式，并使用值类(value class)来实现pimp-my-library模式，pimp-my-library模式将会创建一个隐式包装器类，将方法添加到已有的类上，本质上以面向对象的方式调用新的方法。

implicit class Future_PimpMyFuture[T](val self: Future[T]) extends AnyVal {
    def get : T = Await.result(self, Duration.Inf)
  }
implicit class Future_PimpMyTraversableOnceOfFutures[A, M[AA] <: TraversableOnce[AA]](val self: M[Future[A]]) extends AnyVal {
    /** @return a Future of M[A] completes once all futures have completed */
    def sequence(implicit cbf: CanBuildFrom[M[Future[A]], A, M[A]], ec: ExecutionContext) : Future[M[A]] =
      Future.sequence(self)
  }

然后以下面的方式使用：

val futResult : Future[List[Unit]] =
    someInts
      .grouped(3)
      .toList
      .foldLeft(Future.successful(List[Unit]())) { (futAccumulator,group) =>
        for { 														// 1
          accumulator <- futAccumulator
          innerResult <- group.map(svc.doSomething _).sequence 		// 2
        } yield accumulator ::: innerResult
      }
 
val result : Unit = futResult.get 									// 3

1. 将Future.flatMap和嵌套的Future.map替换为更清晰易懂的 for 表达式
2. 使用上面预定义的“语法糖方法”替换Future.sequence
3. 使用上面预定义的“语法糖方法”替换Await.result

再次简化

在一个新的值类Future_PimpMyTraversableOnce创建另一个 pimp-my-library方法。

implicit class Future_PimpMyTraversableOnce[A, M[AA] <: TraversableOnce[AA]](val self: M[A]) extends AnyVal {
    /** @return a Future of M[B] that completes once all futures have completed */
    def mapAsync[B](groupSize: Int)(f: A => Future[B])(implicit
      cbf: CanBuildFrom[M[Future[A]], A, M[A]],
      cbf2: CanBuildFrom[Nothing, B, M[B]],
      ec: ExecutionContext) : Future[M[B]] = {
      self
       .toList 		// 1
       .grouped(groupSize)
       .foldLeft(Future.successful(List[B]())) { (futAccumulator,group) =>
         for {
           accumulator <- futAccumulator
           innerResult <- group.map(f).sequence
         } yield accumulator ::: innerResult
       }
       .map(_.to[M]) // 2
    }
  }

1. 转换为List以有效的进行结果累积
2. 转换为预期的集合

然后使用：

val futResult : Future[List[Unit]] = someInts.mapAsync(3)(svc.doSomething _)
val result : Unit = futResult.get

1.8 - Future-Promise

介绍

Promise是一个可以被一个值或一个异常完成的对象。并且只能完成一次，完成后就不再可变。称为单一赋值变量，如果再次赋值则会引发异常。

Promise值的类型为Promise[T]，可以通过其伴生对象中的Promise.apply()创建一个实例：

def apply[T](): Promise[T]

调用该方法后会立即返回一个Promise实例，它是非阻塞的。当新的Promise对象被创建后，不会包含值或异常，通过success和failure方法分别赋值为值或异常。

通过complete可以提供一个Try[T]实例来填充Promise，这时Promise的值是一个值还是一个异常，取决于Try[T]最终是一个包含值的Sucess还是一个包含异常的Failure对象。

每个Promise对象都明确对应一个Future对象，通过future方法获取关联的Future对象，并且无论调用该方法多少次，都会放回相同的Future对象。

与success/failure/complete对应的方法是trySuccess/tryFailure/tryCompletee，这些方法会尝试对Promise进行赋值并返回赋值操作是否成功的布尔值。而基本的success/failure/complete操作返回的是则是对原Promise的引用。

object Promise

Promise的伴生对象，一共定义了四种构造器。

apply

def apply[T](): Promise[T] = new impl.Promise.DefaultPromise[T]()

它不接受然和参数，创建一个能够被类型为T的值完成的Promise对象。即创建它时只需要设置预期被完成的值的类型：

val promise: Promise[User] = Promise[User]()

fromTry

def fromTry[T](result: Try[T]): Promise[T] = new impl.Promise.KeptPromise[T](result)

提供一个Try[T]类型的值，并返回一个被完成后的Promise对象。这个结果Promise中是一个值还是异常，取决于传入的Try[T]最终是一个Success还是一个Failure。

failed

def failed[T](exception: Throwable): Promise[T] = fromTry(Failure(exception))

通过传入一个异常创建一个被该异常完成的Promise对象。

successful

def successful[T](result: T): Promise[T] = fromTry(Success(result))

通过传入一个值创建一个被该值完成的Promise对象。

trait Promise

isCompleted

判断该Promise是否已被完成，返回一个布尔值。

complete & tryComplete

def complete(result: Try[T]): this.type =
    if (tryComplete(result)) this 
    else throw new IllegalStateException("Promise already completed.")

def tryComplete(result: Try[T]): Boolean

tryComplete方法尝试通过传入的Try[T]来完成该Promise，返回一个该操作成功失败的布尔值。需要注意的是，虽然返回的是一个布尔值，但这个布尔值表示，该 Promise 之前没有被完成并且已经被当前的操作完成，或在调用该方法之间就已经被完成。

因此，在complete方法中，通过传入一个Try[T]来完成一个Promise，实际上会在内部调用tryComplete，如果``tryComplete返回true，表示该Promise还没有被完成并通过这次操作成功完成，同时返回该Promise`的引用，否则则报错已经被完成过。

completeWith & tryCompleteWith

final def completeWith(other: Future[T]): this.type = tryCompleteWith(other)
final def tryCompleteWith(other: Future[T]): this.type = {
    other onComplete { this tryComplete _ }
    this
  }

与complete和tryComplete类似，不过他接收的是一个Future[T]而不是一个Try[T]。

success & trySuccess

def success(@deprecatedName('v) value: T): this.type = complete(Success(value))
def trySuccess(value: T): Boolean = tryComplete(Success(value))

success方法通过一个值来完成Promise，而trySuccess则首先将传入的值包装为一个Success[T ]然后调用前面的tryComplete方法，尝试完成Promise并返回一个布尔值。

failure & tryFailure

def failure(@deprecatedName('t) cause: Throwable): this.type = complete(Failure(cause))
def tryFailure(@deprecatedName('t) cause: Throwable): Boolean = tryComplete(Failure(cause))

与success和trySuccess处理过程相同，只是通过一个异常而不是一个值来完成Promise

future

def future: Future[T]

获取该Promise对应的Future。

总结

• 一个Promise有两种构造方式，构造为未完成的、构造为已完成的
• 一个Promise只能调用完成方法一次，无论是哪个完成方法，再次调用将抛出已完成异常
• 一个Promise只与一个Future对应，无论调用多少次future方法都会返回相同的Future

1.9 - Implicits-基础

《Programming in Scala 3rd》- Implicit Conversions And Parameters

主要解决的问题是扩展已有的对象。

隐式转换

每个库对实质上相同的概念有其各自不同的编码方式，隐式转换用于减少两种类型之间的显式转换操作。

隐式-规则

这些隐式定义是编译器允许的、被用于插入到程序中以用来解决类型错误问题。

• 标记规则：只有那些被关键字implicit标记的定义
• 作用域规则：被插入的隐式转换在作用域中必须是一个单独的标示符，或者是在被转换对象的伴生对象中。必须直接引入该隐式定义，而不是拥有该定义的对象。比如需要convert，它属于一个对象object，只有直接通过import object.convert才有效。需要的隐式定义在伴生对象中时则不需要显式引入。
• 一次一个规则：只有一个隐式被插入。编译器永远不会将x + y重写为convert1(convert2(x)) + y。
• 显式优先规则：无论何时以代码编写的方式类型检查，都不会尝试隐式。编译器不会再去改变已经运行的代码。因此你可以随时使用显式定义替换隐式定义。

隐式转换到一个指定的类型

如果编译器看到一个 X，但是需要的是一个 Y，这时他会寻找隐式转换函数来将 X 转换为 Y。

隐式转换方法调用者

如果编译器看到如下代码obj.toInt，但是对象obj并不拥有toInt方法，这是会尝试查找拥有该方法的类型并尝试进行隐式转换。

与新类型互操作

1.10 - Implicits-进阶

隐式转换的用途：

• DSL
• Type evidence
• 减少代码冗余
• Type class
• 编译期 DI
• 扩展现有库

需要注意的地方：

• 解决规则会变得困难
• 自动转换
• 不要过度使用

隐式转换

一个普通的方法：

def makeString(i:Int):String = s"makeString: ${i.toString}"

以正常方式调用：

makeString(100)

但是如果我们有一个其他非 Int 类型的对象需要作为该方法的参数，则需要提供一个隐式转换，将其他类型转换为需要的 Int 类型：

case class Balance(amount:Int)
val balance = Balance(100)

implicit def balance2Int(balance:Balance):Int = balance.amount
makeString(balance)

JavaConversion & JavaConverters

在与 Java 互操作时，比如我们的方法需要一个 Scala 类型的集合，而原有代码只能提供 Java 类型的集合，这时可以引入 Scala 中预定义的两种类型的隐式转换：

val javaList:java.util.List[Int] = java.util.Array.asList(1,2,3)
def someDefUsingSeq(seq:Seq[Int]) = println(seq)
import scala.collection.JavaConversions._
someDefUsingSeq(javaList)

或者以更好的方式，在转换时显示指定：

import scala.collection.JavaConverters
someDefUsingSeq(javaList.asScala)

隐式视图

如果我们需要包装或扩展一个已有的类型对象：

class StringWrapper(s:String){
  def quoted = s"$s"
}

可以以下面的方式调用：

new StringWrapper("string").quoted

但是并不能以下面的方式调用：

"string".quoted

这时，可以定义一个从String到StringWrapper的视图作为隐式转换：

implicit def warpString(s:String):StringWrapper = new StringWrapper(s)
"string".quoted		// "string" 会通过隐式转换自动转换为一个 StringWrapper 对象

视图绑定：废弃。

隐式参数

声明一个带有隐式参数的方法：

def giveMeAnInt(implicit i: Int) = i

可以以正常的方式调用该方法：

giveMeAnInt(1)

以隐式的方式提供参数：

implicit val someInt = 100
giveMeAnInt	// 100

但是如果同时提供多个隐式 Int 类型值，则会报错。

隐式类

假如其他的库已经定义了一个类：

case class Balance(amount:Int)
val balacne = 100

如果这时我们想对它做些操作，比如：

-balance

这时，我们可以创建一个包装类来扩展它：

implicit class RichBalance(val balance:Balance){
  def unary-: Balance = balance.copy(amount = -balance.amount)
}

这种用法主要用于扩展其他已有的库或类型。

隐式声明

作用域

查找优先级：

• 通过名字，不使用任何前缀，当前作用域
• 在隐式作用域中：
  • 伴生对象
  • 包对象
    • 源类型的包对象
    • 参数和超类、超特质的包对象

Type class

1.11 - Trait-基础

原理

定义特质

trait Philosophical{
  def philosophical() {
    println("I consume memory, therefore I am!")
  }
}

除了使用trait关键字，与类的定义一样，也没有声明超类，因此只有一个默认的AnyRef作为超类。同时定义了一个具体的方法。

在类中混入特质

然后将特质混入到一个类中：

class Forg extends Philosophical {
  override def toString = "green"
}

可以使用extends或with混入特质，混入特质的类同时将会隐式的继承特质的超类。

从特质继承的方法可以向使用超类中的方法一样：

val forg = new Forg()
forg.philosophical()		// I consume mem...

特质也是类型

val phil: Philosophical = forg
phil.philosophical()		// I consume mem...

phil变量被声明为Philosophical类型，因此它可以被初始化为任何继承了Philosophical特质的类的实例。

混入多个特质

如果需要将特质混入到一个继承自超类的类里，可以使用with来混入特质，或者使用多个with混入多个特质：

class Animal
trait HasLegs
class Forg extends Animal with Philosophical with HasLegs{
  override def toString = "green"
}

重写特质方法

class Forg extends Philosophical {
  override def toString = "green"
  override def philosophical() {
    println("It ain't easy being $toString!")
  }
}

这时，类Forg的实例仍然可以赋值到Philosophical类型的变量，但是其方法已经被重写。

特质与类的不同

特质类似于带有具体方法的 Java Interface。特质能够实现类的所有功能，但是有两点差别：

• 特质没有构造器
• 无论类的所处位置，super调用都是静态绑定的。但是特质中是动态绑定的。因为可以同时混入多个特质，其绑定会基于混入特质的顺序。

胖瘦接口

特质一种主要的应用方式是更具类已有的方法自动为类添加方法。但是在 Java 的接口中，如果需要多个接口的相互继承，必须在子接口中声明所有父接口的抽象方法。而在 Scala 中，可以通过定义一个包含部分抽象方法的特质，和一个包含大量已实现方法的特质，子类在继承多个特质后只需要实现抽象方法部分，并且同时能够获得需要的所有方法。

实例：Ordered 特质

比如一个需要比较的对象，希望使用>或<等操作符来进行比较：

class Rational(n:Int, d:Int){
  // ...
  def < (that.Rational) = this.numer * that.denom > that.numer * this.denom
  def > (that.Rational) = that < this
  def <= (that:Rational) = (this < that) || (this == that)
  def >= (that.Rational) = (this > that) || (this == that)
}

一共定义了 4 中操作符，并且后续的 3 中都是基于第一个方法，这是一个胖接口的典型，如果是瘦接口的话，只会顶一个一个<操作符，然后其他的功能由客户端自己实现。

这些用法很常见，因此 Scala 专门提供了一个Ordered特质，只需要定义一个compare方法，然后Ordered会自动创建所有的比较操作。比如：

class Rational(n:Int, d:Int) extends Ordered[Rational]{
  def compare(that:Rational) = 
    (this.numer * that.denom) - (that.numer - this.denom)
}