Scala 类型系统：泛型与类型推断

Scala 类型系统：泛型与类型推断

Scala 的类型系统以严谨和灵活著称，其中泛型和类型推断是编写可复用、简洁代码的核心工具。掌握这两项技术，可以显著减少冗余代码，并在编译期捕获潜在错误。

一、 定义与使用泛型类

泛型允许你编写可以处理多种类型的代码，而不需要为每种类型重复编写逻辑。最常见的需求是创建一个可以存放任意类型数据的容器。

编写一个基本的泛型类。

在代码编辑器中输入以下内容，定义一个名为 Box 的类，它使用类型参数 T 来存储内容：

class Box[T](val content: T)

实例化该泛型类。

在使用时，指定具体的类型参数，或者交由编译器进行推断。运行以下代码进行测试：

// 显式指定类型为 String
val stringBox = new Box[String]("Hello Scala")

// 让编译器推断类型为 Int
val intBox = new Box(100)

访问内部数据。

调用 content 属性获取数据：

println(stringBox.content) // 输出: Hello Scala
println(intBox.content)    // 输出: 100

二、 理解与运用类型变化

在泛型系统中，类型变化决定了带有泛型参数的类（如 List[Dog]）是否可以被视为另一种类型（如 List[Animal]）的子类。Scala 提供了协变、逆变和不变三种机制。

掌握三种变化的定义与区别。

下表总结了三种类型变化的特性及其在类定义中的符号表示。

创建一个协变类。

假设有一个动物类层级结构，我们希望装猫咪的盒子能被当作装动物的盒子使用。定义如下类结构：

class Animal
class Cat extends Animal

// 使用 +T 表示协变
class CovariantBox[+T]

val catBox: CovariantBox[Cat] = new CovariantBox[Cat]
val animalBox: CovariantBox[Animal] = catBox // 编译通过，Cat 是 Animal 的子类，CovariantBox[Cat] 也是 CovariantBox[Animal] 的子类

注意：协变类型参数 T 通常不能出现在类中函数的输入参数位置（即不能作为“消费者”），只能出现在输出位置（作为“生产者”），否则会导致类型不安全。

三、 利用类型推断简化代码

Scala 编译器具备强大的类型推断能力，能够根据上下文自动推导出表达式的类型。合理利用这一特性，可以让代码更加接近自然语言，减少噪音。

省略显式类型声明。

定义变量时，使用 val 或 var 关键字，但不写明类型，让编译器根据右值推断：

val number = 42          // 推断为 Int
val message = "Hi"       // 推断为 String
val list = List(1, 2, 3) // 推断为 List[Int]

利用泛型方法的推断。

编写一个泛型方法，并在调用时省略类型参数。输入以下工具方法：

def identity[T](arg: T): T = arg

调用该方法：

// 无需写 [String]，编译器知道 "test" 是字符串
val result = identity("test") 

处理复杂表达式的推断。

在链式调用中，编译器会根据后续的操作推断中间变量的类型。执行以下代码：

val numbers = List(1, 2, 3, 4)
// filter 参数 x 的类型被推断为 Int
val doubled = numbers.filter(x => x > 2).map(x => x * 2)

四、 综合实战：构建类型安全的通用处理器

结合泛型与类型推断，我们可以构建一个既能处理不同数据类型，又能保持类型安全的通用处理器。这里我们将实现一个简单的“结果”包装器，用于模拟可能失败的操作。

定义 Result 泛型类。

这个类使用协变 +T，因为我们主要从中“读取”成功的值。同时，定义两个子类 Success 和 Failure。

sealed trait Result[+T]
case class Success[+T](value: T) extends Result[T]
case class Failure(error: String) extends Result[Nothing]

编写通用处理逻辑。

定义一个函数，它接收一个 Result，并根据成功或失败执行不同的操作。这里利用类型推断来处理 value 的类型。

def handleResult[T](result: Result[T]): String = result match {
  case Success(v) => s"操作成功，结果: $v" // v 的类型自动推断为 T
  case Failure(e) => s"操作失败，原因: $e"
}

测试处理器。

创建不同的结果实例并传入处理函数。注意观察调用时无需指定 [T] 的具体类型。

val res1: Result[Int] = Success(100)
val res2: Result[String] = Failure("网络连接超时")

// 调用时，编译器自动推断 handleResult 中的 T 为 Int
println(handleResult(res1)) 

// 调用时，编译器自动推断 handleResult 中的 T 为 String (虽然实际匹配的是 Failure)
println(handleResult(res2)) 

进阶：使用上下文界定 进行隐式推断。

假设我们需要比较两个 Result 中的值（前提是它们都是 Success 且值本身可比较）。我们可以使用 Ordering 上下文界定。

// 要求类型 T 必须有一个隐式的 Ordering[T]
def maxResult[T : Ordering](r1: Result[T], r2: Result[T]): Result[T] = (r1, r2) match {
  case (Success(v1), Success(v2)) => 
    // 使用 implicitly 获取隐式比较器
    val ord = implicitly[Ordering[T]]
    if (ord.gteq(v1, v2)) r1 else r2
  case _ => Failure("无法比较，其中包含失败结果")
}

val a = Success(10)
val b = Success(20)
// 编译器自动寻找 Ordering[Int]，并推断 T 为 Int
println(handleResult(maxResult(a, b)))