Scala之旅-变化（VARIANCES）

今天药忘吃喽~ 2022-05-24 00:22 154阅读 0赞

***变化***（Variance）是***复杂类型的子类型关系***与***组件类型的子类型关系***之间的相关性。***Scala*** 支持泛型类的参数类型的变化注解（variance annotations），如果没有使用注解，则允许它们是***协变的***（covariant），**逆变的**（contravariant）或**不可变的\***（invariant）。

在类型系统中使用变化（variance）允许我们在复杂类型之间做出直观的连接，而缺少变化（ variance） 可能会限制抽象类的复用。

class Foo[+A] // 协变类
    class Bar[-A] // 逆变类
    class Baz[A] // 不变类

## 协变（Covariance） ##

泛型类的类型参数 `Ａ` 可以使用注解 `+A` 进行协变。对于某个 `class List[+A]`，使 `A` 协变表示对于 `A` 和 `B` 类型而言，如果 `A` 是 `B` 的子类型，那么 `List[A]` 就是 `List[B]` 的子类型。这使得我们可以使用泛型来做非常有用和直观的子类型关系。  
考虑这个简单的类结构

abstract class Animal { 
      def name: String
    }
    case class Cat(name: String) extends Animal
    case class Dog(name: String) extends Animal

`Cat` 和 `Dog` 都是 `Animal` 子类型。***Scala*** 标准库中有一个通用不变的类 `sealed abstract class List[+A]`，其中的类型参数 `A` 是协变的。这意味着 `List[Cat]` 是一个 `List[Animal]` 并且 `List[Dog]` 也是一个 `List[Animal]` 。直观的说，每一个猫列表和狗列表都是动物列表，你可以把它们中任何一个替换为 `List[Animal]` 。

在接下来的例子里，方法 `printAnimalNames` 将接受一个动物集合作为参数并在新行上分别输出它们的名称。如果 `List[A]` 不是协变的，那么最后两个方法调用将不会通过编译，这将会严重限制 `printAnimalNames` 方法的有效性。

object CovarianceTest extends App { 
      def printAnimalNames(animals: List[Animal]): Unit = {
        animals.foreach { animal =>
          println(animal.name)
        }
      }
    
      val cats: List[Cat] = List(Cat("Whiskers"), Cat("Tom"))
      val dogs: List[Dog] = List(Dog("Fido"), Dog("Rex"))
    
      printAnimalNames(cats)
      // Whiskers
      // Tom
    
      printAnimalNames(dogs)
      // Fido
      // Rex
    }

## 逆变（Contravariance） ##

泛型类的参数类型 `A` 可以通过注解 `-A` 进行逆变。这在类与它的类型参数之间建立了子类型关系，但与我们获得的协变类型是相反的。也就是说，对于某个类 `class Writer[-A]`，使 `A` 逆变意味着对于 `A` 和 `B` 两种类型来说，如果 `A` 是 `B` 的子类型，那么 `Writer[B]` 就是 `Writer[A]` 的子类型。

接下来的例子仍然使用上面定义的 `Cat`，`Dog` 和 `Animal`：

abstract class Printer[-A] { 
      def print(value: A): Unit
    }

`Printer[-A]` 是一个用于输出某种类型 `A` 的简单类。接下来为特定地类型定义一些子类：

class AnimalPrinter extends Printer[Animal] { 
      def print(animal: Animal): Unit =
        println("The animal's name is: " + animal.name)
    }
    
    class CatPrinter extends Printer[Cat] { 
      def print(cat: Cat): Unit =
        println("The cat's name is: " + cat.name)
    }

如果 `Printer[Cat]` 知道如何打印任何 `Cat` 到控制台，并且 `Print[Animal]` 知道如何打印 `Animal` 到控制台，那就意味着 `Print[Animal]` 也知道如何打印 `Cat`。相反则不适用，因为 `Printer[Cat]` 不知道如何打印 `Animal` 到控制台。因此，如果我们愿意，我们应该可以使用 `Print[Animal`\] 替换 `Printer[Cat]`，那么让 `Printer[A]` 逆变允许我们做到这一点。

object ContravarianceTest extends App {  
      val myCat: Cat = Cat("Boots")
    
      def printMyCat(printer: Printer[Cat]): Unit = {
        printer.print(myCat)
      }
    
      val catPrinter: Printer[Cat] = new CatPrinter
      val animalPrinter: Printer[Animal] = new AnimalPrinter
    
      printMyCat(catPrinter)
      printMyCat(animalPrinter)
    }

![这里写图片描述][70]  
程序的输出结果为：

The cat's name is: Boots
    The animal's name is: Boots

![这里写图片描述][70 1]

## 不可变（Invariance） ##

***Scala*** 中的泛型类默认是不可变的。这意味着它们既不是协变（covariant） 也不是逆变（contravariant）。下面的例子中，`Container` 类是不可变的。`Container[Cat]` 不是 `Container[Animal`\]，反过来也不是。

class Container[A](value: A) { 
      private var _value: A = value
      def getValue: A = _value
      def setValue(value: A): Unit = {
        _value = value
      }
    }

看起来 `Container[Cat]` 自然也应该是 `Container[Animal]`，但是让一个可变的泛型类成为协变类型将是不安全的。在这个例子中，`Container` 不可变是很重要的。假设 `Container` 实际上是协变的，那么有时可能会发生以下情况：

val catContainer: Container[Cat] = new Container(Cat("Felix"))
    val animalContainer: Container[Animal] = catContainer
    animalContainer.setValue(Dog("Spot"))
    val cat: Cat = catContainer.getValue // 我们把狗分配给了猫

![这里写图片描述][70 2]  
编译器提示错误：`Container[Cat]` 类型表达式不符合预期的 `Container[Animal]` 类型。  
幸运的是，编译器会自动终止我们这个错误的程序。

## 其他例子 ##

另一个可以帮助理解变化(variance)的例子是来源于 ***Scala*** 标准库的 `trait Function1[-T, +R]` 。`Functionl` 是带一个参数的函数，它的第一个参数类型 `T` 表示参数的类型，第二个参数类型 `R` 表示返回类型。`Functionl` 在它的参数类型上是逆变的，返回类型是协变的。对于这个例子，我们将使用文字符号 `A => B` 表示 `Functionl[A,B]` 。

假设在先前使用的 `Cat`，`Dog`，`Animal` 继承树基础上再增加以下类：

abstract class SmallAnimal extends Animal
    case class Mouse(name: String) extends SmallAnimal

假设我们这个函数接受动物类型并返回它们吃的食物类型。如果我们想要一只 `Cat => SmallAnimal`（因为猫爱吃小动物），但是用 `Animal => Mouse` 代替，我们的程序也会正常工作。直观来讲 `Animal => Mouse` 也可以接受一个 `Cat` 作为参数，因为 `Cat` 就是 `Animal`，并且返回 `Mouse`（也是 `SmallAnimal`）。既然我们可以安全隐形的使用后者替代前者，那么我们可以说 `Animal => Mouse` 是 `Cat => SmallAnimal` 的子类型。

## 与其他语言比较 ##

一些类似于 ***Scala*** 的语言以不同的方式支持变化（Variance）。例如，***Scala*** 中的变化注解（variance annotations）与 ***C\#*** 中的非常类似，其中在抽象类定义时就已添加注解（声明式 variance）。但是，在 ***Java*** 中，当抽象类被使用时，客户端才会提供注解（使用式 variance）。

[70]: /images/20220524/2081cf4cc3cf4926948193073dd9be09.png
[70 1]: /images/20220524/d110d965e2bf4386b6b262361cdc12e6.png
[70 2]: /images/20220524/fc8f61e328ce4d4aab6d61e1234af817.png