Scala

Scala的设计工作是由马丁·奥得斯基于2001年在洛桑联邦理工学院 (EPFL)(瑞士洛桑)开始进行。Scala的设计源自Funnel语言的工作，Funnel是一种结合了函数式编程和佩特里网的编程语言。^[7] 奥得斯基曾参与了Java泛型和Sun公司的Java编译器javac的开发研究工作。^[7]

在2003年年底发布内部测试后，Scala于2004年初在Java平台公开发布，^[8][3][7][9] Scala第二个版本(2.0版)于2006年3月发布。^[3]

2011年1月17日，Scala团队获得了来自欧洲研究理事会价值230多万欧元的五年研究资助 。^[10] 2011年5月12日，奥得斯基和合作伙伴成立了Typesafe公司(后来更名为Lightbend公司)，一家为Scala提供商业支持、培训和服务的公司。Typesafe在2011年从Greylock Partners投资机构获得了300万美元的投资。^{[11][12][13][14]}

Scala在Java平台（Java虚拟机）上运行，并兼容现有的Java 程序。^[8] 由于安卓应用程序通常用Java编写，并且在打包时从Java字节码转换为Dalvik字节码(在安装过程中可能被进一步编译成机器码)，因此Scala的Java兼容性使其非常适合安卓开发，在函数式开发上尤其是如此。^[15]

Scala软件发行版，包括编译器和库，是在Apache许可下发布的。^[16]

2.1 其他编译器和它们目标

Scala.js 是一个将Scala程序编译为JavaScript的编译器，它的问世使得可以在web浏览器或Node.js中运行Scala程序。^[17] 该编译器自2013年开始开发，并于2015年宣布结束试验阶段(v0.6)。v1.0.0-M1版于2018年6月发布，但在2019年仍是M7版。^[18]

Scala Native是一个Scala编译器，它以LLVM编译器基础结构为目标，创建使用轻量级运行环境的可执行代码，并在运行时使用贝姆垃圾收集器。该项目由丹尼斯·沙巴林领导，并于2017年3月14日发布第一个版本，0.1版。Scala Native的开发始于2015年，目标是通过消除代码的初始运行时编译使得它比JVM的即时编译更快，并提供直接调用本机例程的能力。^[19][20]

一个针对.NET框架及其通用语言运行平台的参考Scala编译器于2004年6月发布，^[7] 但在2012年被正式放弃。^[21]

3.1 “Hello, World!”的例子

用Scala编写的Hello World程序有以下形式:

 object HelloWorld extends App {
   println("Hello, World!")
 }

不像Java的Hello World程序，Scala中没有类声明，也没有静态声明；而是使用object关键字创建了一个单例对象。

当程序存储在文件HelloWorld.scala中时，用户使用以下命令编译它:

$ scalac HelloWorld.scala

并使用以下命令运行它

$ scala HelloWorld

这一过程类似于编译和运行Java代码的过程。事实上，Scala的编译和执行模型与Java的相同，这使得它与例如Apache Ant等Java构建工具兼容。

“Hello World”Scala程序的一个简短版本是:

println("Hello, World!")

Scala包括了交互式shell和脚本支持。^[22] 将以上程序保存在名为HelloWorld2.scala的文件中，就可以作为脚本运行，无需事先编译，使用命令:

$ scala HelloWorld2.scala

也可以使用选项-e直接将命令输入Scala解释器:

$ scala -e println(“Hello, World！”)”

表达式可以在REPL中以交互方式输入:

$ scala
Welcome to Scala 2.12.2 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_131).
Type in expressions for evaluation. Or try :help.

scala> List(1, 2, 3).map(x => x * x)
res0: List[Int] = List(1, 4, 9)

scala>

3.2 基本示例

以下示例显示了Java和Scala语法之间的差异:

// Java:
int mathFunction(int num) {
    int numSquare = num*num;
    return (int) (Math.cbrt(numSquare) +
      Math.log(numSquare));
}

// Scala: Direct conversion from Java

// no import needed; scala.math
// already imported as `math`
def mathFunction(num: Int): Int = {
  var numSquare: Int = num*num
  return (math.cbrt(numSquare) + math.log(numSquare)).
    asInstanceOf[Int]
}

// Scala: More idiomatic
// Uses type inference, omits `return` statement,
// uses `toInt` method, declares numSquare immutable

import math._
def mathFunction(num: Int) = {
  val numSquare = num*num
  (cbrt(numSquare) + log(numSquare)).toInt
}

这段代码中的一些语法差异是:

• Scala不需要分号来结束语句。
• 值类型首字母大写: Int, Double, Boolean 而不是 int, double, boolean。
• 和Pascal语言一样，参数和返回值的类型声明在变量名后面，而不是如C语言中那样在变量名之前。
• 方法名之前必须有def关键字声明。
• 局部变量或类变量名之前必须有val关键字(表示不可变的变量)或var关键字(表示可变的变量)。
• 函数中不是必须出现(尽管允许)return语句；函数最后执行的语句或表达式的值就是函数的返回值。
• Scala使用foo.asInstanceOf[Type]或特定的函数，例如toDouble或者toInt，来转换变量类型，而不是使用Java类型转换运算符(Type) foo。
• Scala使用import foo._引入包或者库，而不是使用Java的import foo.*;语句。
• 函数或方法foo()也可以直接以foo语句调用；方法 thread.send(signo) 也可以直接用thread send signo调用；并且方法 foo.toString()也可以直接被foo toString调用。

这些语法上的宽松的设计目的是为了支持一些特定领域语言。

其他一些基本的句法差异:

• 数组的引用像函数调用一样，用array(i)调用，而不是 array[i]。(在Scala内部，前者扩展为array.apply(i)方法，返回引用)
• 泛型声明写成List[String]而不是Java的List<String>
• Scala有实际的单例对象Unit代替void类型(见下文)。

3.3 带类的示例

下面的例子对比了Java和Scala中类的定义。

// Java:
public class Point {
  private final double x, y;

  public Point(final double x, final double y) {
    this.x = x;
    this.y = y;
  }

  public Point(
    final double x, final double y,
    final boolean addToGrid
  ) {
    this(x, y);

    if (addToGrid)
      grid.add(this);
  }

  public Point() {
    this(0.0, 0.0);
  }

  public double getX() {
    return x;
  }

  public double getY() {
    return y;
  }

  double distanceToPoint(final Point other) {
    return distanceBetweenPoints(x, y,
      other.x, other.y);
  }

  private static Grid grid = new Grid();

  static double distanceBetweenPoints(
      final double x1, final double y1,
      final double x2, final double y2
  ) {
    return Math.hypot(x1 - x2, y1 - y2);
  }
}

// Scala
class Point(
    val x: Double, val y: Double,
    addToGrid: Boolean = false
) {
  import Point._

  if (addToGrid)
    grid.add(this)

  def this() = this(0.0, 0.0)

  def distanceToPoint(other: Point) =
    distanceBetweenPoints(x, y, other.x, other.y)
}

object Point {
  private val grid = new Grid()

  def distanceBetweenPoints(x1: Double, y1: Double,
      x2: Double, y2: Double) = {
    math.hypot(x1 - x2, y1 - y2)
  }
}

上面的代码显示了Java和Scala处理类的一些概念上的差异:

• Scala没有静态变量或方法。相反，它有单例对象，其本质上是只有一个实例的类。单例对象的声明使用object关键字，而不是class。通常将静态变量和静态方法放在单例对象中，其名称与类名相同，后者也被称为伴生对象。^[8] (单例对象的基础类名后有一个$。因此，对于class Foo伴生对象object Foo，在底层有一个包含伴随对象的代码的类Foo$ ，并使用单例模式。)
• Scala用类参数取代了构造函数参数 ，这些参数作用于类上，类似于函数的参数。当用val或者var修饰符声明时，字段也用相同的名称定义，并根据类参数自动初始化。(在底层，对公共字段的外部访问总是通过自动创建的访问方法(getter)和增变(setter)方法。访问方法与字段同名，这就是为什么在上面的示例中显式声明访问方法是没有必要的。)注意，也可以像Java一样声明替代构造函数。将进入默认构造函数(而不是初始化成员变量)的代码直接进入类级别。
• Scala中的默认可见性是public。

Scala具有与Java和C#相同的编译模型，即单独编译和动态类加载，以便Scala代码可以调用Java库。

Scala的操作特性与Java的相同。Scala编译器生成的字节代码与Java编译器生成的几乎相同。^[8] 事实上，Scala代码可以是反编译为可读的Java代码，但某些构造函数操作除外。对于Java虚拟机 (JVM)、Scala代码和Java代码是无法区分的。唯一的区别是一个额外的运行时库，scala-library.jar。^[23]

与Java相比，Scala增加了大量的特性，并且在表达式和类型的底层模型上有一些根本的差异，这使得该语言理论上更加简洁，并且消除了Java几个极端情况 。从Scala的角度来看，这些特性实际上很重要，因为Scala中的几个新增特性也可以在C#中可用。例子如下:

4.1 语法灵活性

如上所述，与Java相比，Scala具有很大的语法灵活性。以下是一些例子:

• 分号是不必要的；如果行在不常见的位置开始或结束，或者如果有未闭合的圆括号或方括号，则行会自动连接。
• 任何方法都可以用作中缀运算符，例如"%d apples".format(num)和"%d apples" format num是等效的。事实上，因为函数名被允许由任意符号序列组成(除了一些必须特别处理的圆括号、方括号和大括号例外)，像+和<<这样的算术运算符就像任何其他方法一样；这种符号命名方法经历的唯一特殊处理涉及优先级的处理。
• 方法 apply 和 update 再句法上有简写形式。foo()-其中foo是一个值(单例对象或类实例)—是foo.apply()的缩写，而foo() = 42是foo.update(42)的缩写 。同样地，foo(42)是foo.apply(42)的缩写，而foo(4) = 2是foo.update(4, 2)的缩写。这用于collection类，并扩展到许多其他的类，例如软件事务内存单元。
• Scala区分无参数(def foo = 42)和空参数(def foo() = 42)方法。当调用空参数方法时，可以省略括号，这在调用不知道这种区别的Java库时很有用，例如，使用 foo.toString代替foo.toString()。按照惯例，一个方法在执行时应该用空参数来定义函数副作用。
• 以冒号(:)结尾的方法名期望参数在左边，接收器在右边。例如4 :: 2 :: Nil与Nil.::(2).::(4)作用相同，前一种形式直观上和输出结果相对应(具有第一元素4和第二元素2的列表)。
• 类体变量可以透明地实现为独立的getter和setter方法。对于trait FooLike { var bar: Int }，实现可以是object Foo extends FooLike { private var x = 0; def bar = x; def bar_=(value: Int) { x = value }} } }。调用时，仍然能够使用简洁的foo.bar = 42。
• 方法调用中允许使用大括号。这允许新控制结构的纯库实现。^[24] 例如，breakable { ... if (...) break() ... }中， breakable 看起来好像是关键字，但实际上只是一种方法的thunk申明。采用thunks的方法或函数通常将它们放在第二个参数列表中，允许括号和花括号的混合使用: Vector.fill(4) { math.random } 与Vector.fill(4)(math.random)相同 。花括号变量允许表达式跨越多行。
• For表达式(下面将进一步解释)可以适应任何一元方法定义的类型，例如map,flatMap和filter。

就其本身而言，这些选择看起来可能是有问题的，但总的来说，它们的目的是允许在Scala中定义特定领域语言，而不需要扩展编译器。例如， Erlang向actor发送消息的特殊语法，即actor ! message可以(并且正在)在Scala库中实现，而不需要语言扩展。

4.2 统一类型系统

Java对原生类型(例如 int 和 boolean)和引用类型(任何其他的类)之间有明显的区分。只有引用类型是继承方案的一部分，派生自java.lang.Object。在Scala中，所有类型都继承自顶级类 Any，其直系继承是AnyVal(值类型，例如 Int 和 Boolean)和AnyRef (如Java中的引用类)。这意味着在Scala中没有Java中的原生类型和封装类型之间的区别(例如 int与Integer的区别)；装箱和拆箱对用户来说是完全透明的。Scala 2.10允许用户定义新的值类型。

4.3 For表达式

Scala有for表达式，而不是Java中的foreach循环遍历迭代器，它类似于Haskell等语言中的列表生成，或者Python中的列表生成和生成器表达式结合。For表达式使用 yield关键字允许通过迭代现有集合生成新的集合，并返回相同类型的新集合。它们被编译器翻译成一系列对map,flatMap和filter的调用。不使用yield的情况下，代码将转换为foreach从而达到对命令式循环的近似。

一个简单的例子是:

val s = for (x <- 1 to 25 if x*x > 50) yield 2*x

运行它的结果是以下向量:

Vector(16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50)

(请注意，表达式 1 to 25 不是特殊语法。to方法在Scala标准库中被定义为整数类的一个扩展方法，该方法使用一种被称为隐式转换的技术^[25]，该技术允许向现有类中添加新方法。)

对一个map的迭代更复杂的例子是:

// Given a map specifying Twitter users mentioned in a set of tweets,
// and number of times each user was mentioned, look up the users
// in a map of known politicians, and return a new map giving only the
// Democratic politicians (as objects, rather than strings).
val dem_mentions = for {
    (mention, times) <- mentions
    account          <- accounts.get(mention)
    if account.party == "Democratic"
  } yield (account, times)

语句(mention, times) <- mentions是模式匹配的一个例子(见下文)。对map的迭代会返回一组键值元组，模式匹配使得这一元组被分解为键和值的两个相互独立变量这一过程变得非常容易。类似地，列表生成的结果也返回键值元组，因为源对象(来自变量 mentions)是一个映射，所以这些元组被自动构建到一个映射中。请注意，如果mentions是持有的是元组的列表、集合、数组或其他集合，上面完全相同的代码将产生相同类型的新集合。

4.4 支持函数式编程

虽然Scala支持Java中所有可用的面向对象特性(事实上，以各种方式对它们进行了扩充)，但是Scala还提供了大量通常在函数式编程语言中才能找到的功能。总之，这些特性允许Scala程序以几乎完全函数式的风格编写，也允许函数式编程和面向对象编程混合。

例子有:

• 语句和表达式之间没有区别
• 类型推断
• 具有语义捕获的匿名函数(即闭包)
• 不可变变量和对象
• 惰性求值
• 分隔延续(自2.8起)
• 高阶函数
• 嵌套函数
• 柯里化
• 模式匹配
• 代数数据类型 (通过case类)
• 元组

一切都是表达式

不同于C语言或Java语言，但类似于诸如Lisp的语言，Scala不区分语句和表达式。事实上，所有语句都是有输出值的表达式。C和Java中，声明返回类型为void的函数和像while这样的逻辑上没有返回值的语句，在Scala中被认为是返回一个Unit类型，这是一个单例类型，只有一个该类型的对象。不会有返回值的函数和运算符(例如 throw语句或总是存在非本地异常的函数)逻辑上具有返回类型Nothing，一种不包含对象的特殊类；也就是说，底层类型，即每种可能类的子类。(这反过来又使类Nothing兼容各种类，允许 类型推段的正常工作。)

同样，一个if-then-else“语句”实质上是一个表达式，它产生一个值，即两个分支其中一个的结果。这意味着这种代码块可以插入到任何需要表达式的地方，从而避免在Scala中需要使用到三元运算符：

// Java:
int hexDigit = x >= 10 ? x + 'A' - 10 : x + '0';

// Scala:
val hexDigit = if (x >= 10) x + 'A' - 10 else x + '0'

出于该原因，return语句在Scala中是不必要的，事实上也是不被鼓励的。如同在Lisp中一样，代码块中的最后一个表达式是该代码块的返回值，如果该代码块是函数的主体，代码块的值将由函数返回。

为了明确所有函数都是表达式，即使是返回Unit的方法也是用到了等号

def printValue(x: String): Unit = {
  println("I ate a %s".format(x))
}

或者等效地(使用类型推断，并省略不必要的大括号):

def printValue(x: String) = println("I ate a %s" format x)

类型推断

由于Scala具有类型推段特性，变量、函数返回值和许多其他表达式的类型通常可以省略，这是因为编译器可以推断出它们。例如：val x = "foo"(对于不可变的常数或者不可变对象)或var x = 1.5(对于可以改变其值的变量)。Scala中的类型推断本质上是局部的，这与Haskell，ML等其他更纯函数式语言中使用的更全局的Hindley-Milner算法形成对比。这样做是为了支持面向对象编程。因此，仍然某些类型仍需要被声明(最明显的是函数参数和递归函数的返回类型)，例如

def formatApples(x: Int) = "I ate %d apples".format(x)

或者(为递归函数声明了返回类型)

def factorial(x: Int): Int =
  if (x == 0)
    1
  else
    x*factorial(x - 1)

匿名函数

在Scala中，函数是对象，并且有一个方便的语法来定义匿名函数。一个例子是表达式 x => x < 2，它指定一个带有一个参数的函数，返回这个参数是否小于2。它相当于Lisp语言中的 (lambda (x) (< x 2))。请注意，x的类型和返回类型不需要显式的指定，通常可以通过类型推理判断出来；但是它们也可以被显式的指定，例如(x: Int) => x < 2或者(x: Int) => (x < 2): Boolean。

匿名函数表现为真闭包，这是因为它们自动捕获封在封闭函数环境内词法上可用的任何变量。这些变量即使在封闭函数返回后也是可用的，这与Java的匿名内部类不同，不需要声明为final。(如果这些变量是可变的，甚至可以修改它们，并且修改后的值将在下次调用匿名函数时可用。)

使用占位符变量可以让匿名函数更短：例如，下面的语句:

list map { x => sqrt(x) }

可以更简洁地写成

list map { sqrt(_) }

甚至

list map sqrt

不可变类型

Scala强制区分不可变(不可修改，只读)变量和可变变量，前者的值一旦赋值就不能更改，后者可以更改。不可变对象和可变对象之间也有类似的区别。当一个变量被声明时，必须进行区分：不可变变量是用val声明，可变变量用var。同样地，Scala中所有的集合对象(容器类型)，例如链表，列表，集和哈希表也有可变与不可变之分，不可变变量被认为是更加基本的并且是默认的实现。不可变的变量是“持久”数据类型，这是因为它们创建一个包含旧对象并添加了新成员的新对象；这类似于在Lisp中构建链表的构建方式，在Lisp中，通过创建一个新的“cons”单元以及指向新元素(“head”)和旧列表(“tail”)的指针来添加新的元素。这导致并发非常简单——不需要锁，也不会修改任何的共享对象。不可变的数据结构也被有效地构建，从这方面而言，修改的实例重用大部分旧的实例数据而未使用/未引用的部分由垃圾回收收集。^[26]

惰性(非热切)求值

默认情况下，Scala的求值策略是及早的(“热切的”)。换句话说，Scala会在表达式执行时对其进行求值，而不是在需要时进行。但是，可以使用lazy关键字声明一个变量是非热切的（惰性的），这意味着直到第一次使用该变量时才会计算生成该变量值的代码。Scala中还有各种类型的非及早求值集合(例如Stream类，非及早求值链表)，任何集合都可以用view方法变成为非及早求值的。非及早求值的集合为服务器生成的数据提供了良好的语义匹配，在这种情况下，生成列表的后续元素(进而触发对服务器的请求，可能位于网络上的其他地方)的求值代码只有在实际需要这些元素时才会被执行。

尾递归

函数式编程语言通常通过尾调用优化以允许广泛使用递归而不出现栈溢出问题。Java字节码中的限制使JVM上尾调用优化的实现变得复杂。一般来说，用尾调用调用自身的函数是可以被优化的，但是相互递归的函数不能。有人建议用Trampoline作为变通办法。^[27] 自Scala 2.8.0发布(2010年7月14日)以来，Trampoline由Scala库通过scala.util.control.TailCall被支持。函数可以用@tailrec注释，在这种情况下，除非它是尾递归的，否则它不会编译。^[28]

case类和模式匹配

Scala内置了对模式匹配的支持，它可以被视为更复杂的，可扩展的Switch语句，其中可以匹配任意数据类型(而不仅仅是简单类，如整数、布尔值和字符串)，包括它们的嵌套。Scala提供一种被称为case类的特殊类， 它提供对模式匹配的自动支持，并可用于构建代数数据类型，这种数据类型在许多函数式编程语言中被使用。(从Scala的角度来看，case类只是一个普通类，编译器会自动地或手动指定地为它添加某些行为，例如，提供深度比较和散列的方法定义，以及在模式匹配过程中对case类的构造函数参数进行析构。)

使用模式匹配的快速排序算法示例如下:

def qsort(list: List[Int]): List[Int] = list match {
  case Nil => Nil
  case pivot :: tail =>
    val (smaller, rest) = tail.partition(_ < pivot)
    qsort(smaller) ::: pivot :: qsort(rest)
}

这里的想法是，我们将一个列表划分为小于轴的元素和大于等于枢轴的元素两个部分，递归地对每个部分进行排序，并将结果联合在一起，再将枢轴放在两者之间。这使用了和归并排序和其他快速排序算法相同的分而治之策略 。

match运算符用于对存储在list中的对象进行模式匹配。依次尝试每个case表达式，看它是否匹配，并且首个匹配情况决定了执行结果。在这种情况下，Nil仅匹配文字对象 Nil，而pivot :: tail匹配为非空列表，同时 根据给定的模式析构该列表。在这种情况下，相关代码将可以访问名为pivot的局部变量，该变量指向列表的头部，和另一个变量tail指向列表的尾部。请注意，这些变量是只读的，并且在语义上非常类似于Lisp和Scheme中使用let运算符定义的变量绑定。

模式匹配也发生在局部变量声明中。在这种情况下，调用tail.partition的返回值是一个 元组—在这种情况下，是两个列表。(元组不同于其他类型的容器，例如列表，这是因为它们总是大小固定，并且元素可以是不同的类型——尽管在这里它们都是相同的。)模式匹配是获取元组的两个部分的最简单方法。

_ < pivot是一个对带有占位符变量匿名函数的声明；请参见上面关于匿名函数的部分。

上文的代码中出现了列表运算符 :: (将元素添加到列表的开头，类似于Lisp和Scheme中的cons)和:::(这将两个列表附加在一起，类似于Lisp和Scheme中的append)。尽管外表如此，但这两种操作符都没有“内在意义”。如上所述，任何符号字符串都可以作为函数名，并且应用于对象的方法可以写成“中缀”-形式而不带句点或括号。上面一行写道:

qsort(smaller) ::: pivot :: qsort(rest)

也可以这样写:

qsort(rest).::(pivot).:::(qsort(smaller))

以更标准的方法调用符号规范。(以冒号结尾的方法是右关联的，并绑定到右边的对象。)

偏函数

在上文的模式匹配示例中，match运算符的主体是偏函数，它由一系列case表达式组成，首个匹配的表达式即为结果，类似于Switch语句。在异常处理的try语句中偏函数也被使用:

try {
  ...
} catch {
  case nfe:NumberFormatException => { println(nfe); List(0) }
  case _ => Nil
}

最后，偏函数可以单独使用，调用它的结果相当于对他进行match。例如，上文的快速排序代码可以这样改写:

val qsort: List[Int] => List[Int] = {
  case Nil => Nil
  case pivot :: tail =>
    val (smaller, rest) = tail.partition(_ < pivot)
    qsort(smaller) ::: pivot :: qsort(rest)
}

这里声明了一个只读变量，其类型是从整数列表到整数列表的函数，并将其绑定到偏函数。(请注意，偏函数的单个参数从未被明确声明或命名。)但是，我们仍然可以像调用正常函数一样调用这个变量:

scala> qsort(List(6,2,5,9))
res32: List[Int] = List(2, 5, 6, 9)

4.5 面向对象的扩展

Scala是一种纯粹的面向对象语言，因此，每个值都是一个对象。对象的数据类型和行为由类和特征描述。通过子类化和灵活的基于混入的组合机制扩展类抽象，以避免多重继承问题。

在Scala中，特征是Java中的接口的代替品。Java 8以下的版本中的接口受到高度限制，只能包含抽象函数声明。这导致了一些批评，即在接口中提供便利方法是别扭的(在每个实现中都必须重新实现相同的方法)，并且以向后兼容的方式扩展已发布的接口是不可能的。因为特征总是混入类中，特征类似于混入类，因为它们几乎拥有常规抽象类的所有能力，只缺少类参数(Scala的类参数相当于Java的构造函数参数)。super运算符在特征上表现比较特殊，它允许特征可以除了继承之外还使用组合的方式链接。以下示例是一个简单的窗口系统:

abstract class Window {
  // abstract
  def draw()
}

class SimpleWindow extends Window {
  def draw() {
    println("in SimpleWindow")
    // draw a basic window
  }
}

trait WindowDecoration extends Window { }

trait HorizontalScrollbarDecoration extends WindowDecoration {
  // "abstract override" is needed here in order for "super()" to work because the parent
  // function is abstract. If it were concrete, regular "override" would be enough.
  abstract override def draw() {
    println("in HorizontalScrollbarDecoration")
    super.draw()
    // now draw a horizontal scrollbar
  }
}

trait VerticalScrollbarDecoration extends WindowDecoration {
  abstract override def draw() {
    println("in VerticalScrollbarDecoration")
    super.draw()
    // now draw a vertical scrollbar
  }
}

trait TitleDecoration extends WindowDecoration {
  abstract override def draw() {
    println("in TitleDecoration")
    super.draw()
    // now draw the title bar
  }
}

变量可以这样声明:

val mywin = new SimpleWindow with VerticalScrollbarDecoration with HorizontalScrollbarDecoration with TitleDecoration

mywin.draw()的结果是:

in TitleDecoration
in HorizontalScrollbarDecoration
in VerticalScrollbarDecoration
in SimpleWindow

换句话说，尽管没有一个特征是继承另一个的，draw的调用首先执行TitleDecoration中的代码 (最后一个特征)，然后(通过调用super())通过其他混入特征回到原线程，并最终返回到Window中的代码, 。这类似于装饰模式，但它更简洁并且更不容易出错，这是因为它不需要显式封装父窗口、不需要通过显式转发实现不变的函数，或不需要依赖实例关系的运行时初始化。在其他语言中，可以在编译时通过一个长长的线性继承实现链来类似的效果，但与Scala相比有一个缺点，即必须为所有可能的混入组合声明一个线性继承链。

4.6 表达型系统

Scala配备了一个富有表现力的静态类型系统，该系统主要强制安全和抽象的连贯使用。然而，类型系统并不可靠。^[29] 特别是，该类型系统支持:

• 将类和抽象类型作为对象成员
• 结构类型
• 依赖于路径的类型
• 复合类型
• 显式类型的自我引用
• 泛型类
• 多态方法
• 类型上限和下限
• 协变和逆变
• 注释
• 视图

Scala能够按使用情况推断类型。这使得大多数静态类型声明都是可以忽略的。除非编译器错误中表明需要声明，静态类型一般不需要显式声明。实际上，为了代码清晰起见，一些静态类型声明是必须的。

4.7 类丰富

Scala中的一种常见技术，被称为“丰富我的库(enrich my library)”^[30] (马丁·奥得斯基在2006年最初称之为“添加我的库（pimp my library）”；^[25] 尽管有人因其负面含义与用词不当（pimp有拉皮条之义）^[31]对这一措辞表示不满^[32])，该技术允许像添加到现有类中一样使用新方法。这类似于C#的扩展方法概念，但是它更强大，因为该技术不仅限于添加方法，也可以，比如，用来实现新的接口。在Scala中，这种技术设计声明一个从“接收”方法的类型到装有原始类型新类型(通常是类)的隐式转换，并提供其他方法。如果找不到给定类型的方法，编译器则会自动搜索提供任何适用隐式转换，以提供所需要的类型。

此技术允许使用附加库将新方法添加到现有类中，只有导入附加库的代码才能获得新的功能，并且其他代码不受影响。

以下示例显示了用方法isEven和isOdd类型的丰富Int类

object MyExtensions {
  implicit class IntPredicates(i: Int) {
    def isEven = i % 2 == 0
    def isOdd  = !isEven
  }
}

import MyExtensions._  // bring implicit enrichment into scope
4.isEven  // -> true

导入MyExtensions的成员将扩展类IntPredicates隐式转换带入范围。^[33]

Scala的标准库包括对角色模型的支持，以及对标准的Java并发应用程序接口的支持。 Lightbend公司提供了一个平台^[34] 该平台中有Akka,^[35]一个提供基于角色模型并发的独立开源框架。Akka角色可能是分布式的或者与软件事务存储器（传输器）相结合的。其他的基于信道的消息传递通信顺序流程的实现有Communicating Scala Objects，^[36] 或者简单地通过JCSP。

这里的角色就像一个带邮箱的线程实例。它可以通过system.actorOf创建，重写receive方法来接收消息，并使用!(感叹号)方法发送消息。^[37] 以下示例显示了一个可以接收消息并输出它们的EchoServer。

val echoServer = actor(new Act {
  become {
    case msg => println("echo " + msg)
  }
})
echoServer ! "hi"

Scala，自2.9.0版起，以标准库中整合的Parallel Collections形式提供了内置的数据并行编程的支持^[38]。

以下示例显示了如何使用并行集合来提高性能。^[37]

val urls = List("https://scala-lang.org",  "https://github.com/scala/scala")

def fromURL(url: String) = scala.io.Source.fromURL(url)
  .getLines().mkString("\n")

val t = System.currentTimeMillis()
urls.par.map(fromURL(_))
println("time: " + (System.currentTimeMillis - t) + "ms")

除了对角色模型的支持和数据并行性，Scala还支持带有Futures和Promises的异步编程、软件事务内存和事件流。^[39]

最著名的用Scala编写的开源集群计算解决方案是Apache Spark。此外，Apache Kafka，一种受Spark和其他流处理技术的欢迎发布-订阅模式消息队列，也是用Scala编写的。

在Scala中，有几种方法可以测试代码。 ScalaTest支持多种测试风格，并可以与基于Java的测试框架集成。^[40] ScalaCheck是一个和Haskell中QuickCheck相似的库 。^[41] specs2 是一个用于编写可执行软件规范的库。^[42] ScalaMock提供测试高阶和柯里化函数支持。^[43]JUnit和TestNG是用Java编写的流行测试框架。

Scala经常被被人们与Groovy和Clojure，另外两种也使用JVM的编程语言，作比较。在类型系统中，在每种语言支持面向对象和函数编程的程度上，以及在它们的语法与Java语法的相似性上，都可以发现这些语言之间的巨大差异。

Scala是静态类型的，而Groovy和Clojure都是动态类型。这使得Scala的类型系统更加复杂和难以理解，但几乎允许所有^[29]要在编译时捕获的类型错误，可以导致更快的执行。相比之下，动态类型需要更多的测试来确保程序的正确性，并且通常速度较慢，以便允许更大的编程灵活性和简单性。关于速度差异，当前版本的Groovy和Clojure允许可选的类型注释，以帮助程序在类型实际上是静态的情况下避免动态类型的开销。当使用最新版本的JVM时，这一开销会进一步减少,JVM已通过对动态类型参数定义方法的调用动态指令进行了增强。这些进步缩小了静态类型和动态类型之间的速度差距，尽管像Scala这样的静态类型语言在执行效率优先的情况下仍然是首选。

关于编程范例，Scala继承了Java的面向对象模型，并以各种方式扩展它。Groovy虽然也强面向对象，但更注重减少代码长度。在Clojure中，面向对象编程没有得到重视，函数编程是该语言的主要优势。Scala还有许多功能编程工具，其中包括高级函数式编程语言，例如Haskell，的特性，并试图在两种范例之间保持中立，让开发人员在两种范例之间进行选择，或者更频繁地，组合使用两种范例。

关于与Java的语法相似性，Scala就像Groovy一样，继承了很多Java的语法。另一方面，Clojure遵循Lisp的句法，在外观和哲学上都与Java不同。然而，因为Scala有许多高级特性，学习它也被认为是困难的。尽管Groovy也是一种功能丰富的语言，它并非如此，主要是因为它被主要设计成一种脚本语言。^{[来源请求]}

10.1 编程语言排名

截至2013年，所有基于JVM的语言(Clojure、Groovy、Kotlin、Scala)都远不如最初的Java语言受欢迎，后者通常排名第一或第二，^[86][87] 并且随着时间的推移也在同时进化。

最受欢迎的编程语言排行，^[88] 该排名追踪语言教程的搜索数量，在2018年4月Scala排名第15位，略有下降趋势。尽管紧随其后的是Kotlin，另一种一种基于JVM的语言，有很强的上升趋势，排名第16位，但是这使得Scala成为继Java之后最流行的基于JVM的语言。

编程语言受欢迎程度TIOBE指数^[87]采用互联网搜索引擎排名和相关的出版物数量来评估语言受欢迎程度。截至2018年4月，它显示Scala排名第34位，在过去两年中下降了4位，但是—正如Bugs & Change Requests板块下所提到的—TIOBE意识到其使用搜索词的方法存在问题，他们使用的搜索词可能在一些编程语言社区中不常用。在这个排名中，Scala领先于一些函数式语言，比如Haskell (第42名)，Erlang，但低于其他语言，如Swift (第15名)，Perl(第16名)，go(第19名)和Clojure(第30名)。

TkoughtWorks Technology Radat，是一组基于高级技术专家意见的半年度报告，^[89] 建议Scala入选2013年度语言和框架类别。^[90] 2014年7月，这一评估变得更加具体，现在指的是“Scala的优点”，它被描述为“要成功地使用Scala，你需要研究该语言并对那些适合你的部分有非常强烈的意见，创建你自己对Scala的优点的定义。”。^[86]

RedMonk编程语言排名，根据GitHub上的项目和Stack Overflow上的问题数量对编程语言进行排名，它将Scala排名第14。^[86] 在该排名中，Scala被放在第二阶梯语言中—在Go, PowerShell和Haskell之前，在Swift，Objective-C，Typescript和R之后。然而，在2018年的报告中，Scala的排名连续第三次下降，该排名质疑“Kotlin消耗了Scala多少可用氧气，来使其排名继续飙升”。^[86]

在2018年版的“State of Java”调查中，^[91] 该报告收集了5160名开发人员关于各种Java相关主题的数据，Scala在JVM上其他语言排名中排名第三。与去年的调查相比，Scala在其他JVM语言中的使用率下降了近四分之一(从28.4%降至21.5%)，被Kotlin超越，后者从2017年的11.4%升至2018年的28.8%。

10.2 公司采用情况

• 2009年4月，推特宣布它已将其大部分后端从Ruby转到Scala，并打算转换其余部分。^[92]
• Gilt集团使用Scala和Play Framework。^[93]
• Foursquare使用Scala和Lift。^[94]
• Coursera使用Scala和Play Framework。^[95]
• 苹果公司中的某些团队共同使用Scala，Java和Play Framework。^[96][97]
• 卫报 在2011年4月宣布将其高流量网站guardian.co.uk^[98]从Java迁移到Scala^[99][100]
• 纽约时报 2014年透露其内部内容管理系统Blackbeard 是用Scala、Akka和Play框架实现的。^[101]
• 赫芬顿邮报 与2013年开始使用Scala作为其内容传输系统Athena的一部分。^[102]
• 瑞士联合银行批准将Scala用于一般生产用途。^[103]
• LinkedIn使用Scalatra 微框架管理其Signal API。^[104]
• Meetup对实时API使用Unfiltered工具箱。^[105]
• Remember the Milk使用Unfiltered工具箱、Scala和Akka进行公共应用编程接口和实时更新。^[106]
• Verizon使用Scala打造“一个次世代框架”。^[107]
• Airbnb开发用Java和Scala编写的开源机器学习软件“Aerosolve”。^[108]
• Zalando将它的技术栈从Java转移到Scala和Play。^[109]
• SoundCloud用Scala作为它的后端，并使用诸如Finagle(微服务)Scalding和Spark(数据处理)之类的技术。^{[110] [111]}
• Databricks将Scala用于Apache Spark大数据平台。
• 摩根士丹利在财务和资产相关项目中广泛使用Scala。^[112]
• 谷歌/Alphabet公司中有些团队使用Scala，主要是因为收购其他项目，例如Firebase^[113] 和Nest。^[114]
• 加拿大沃尔玛使用Scala作为他们的后端平台。^[115]
• 多邻国将Scala用于生成课程的后端模块。^[116]
• 海涅曼医学研究中心将Scala用于许多政府税务应用程序。^[117]

2015年3月，推特平台工程小组前副总裁拉弗·克里柯瑞恩表示由于Scala的学习曲线，他本不应该在2011年选择使用Scala。^[118] 同月，领英SVP凯文·斯科特 声明他们决定“尽量减少对Scala的依赖”。^[119] 2011年11月， Yammer公司放弃Scala的原因包括新团队成员的学习曲线以及Scala编译器的不同版本之间的不兼容性。^[120]