了解 Scala 中的上限和下限

Question

我有这个scala代码：

class Creature {
  override def toString = "I exist"
}
class Person(val name: String) extends Creature {
  override def toString = name
}
class Employee(override val name: String) extends Person(name) {
  override def toString = name
}
class Test[T](val x: T = null) {
  def upperBound[U <: T](v: U): Test[U] = {
    new Test[U](v)
  }
  def lowerBound[U >: T](v: U): Test[U] = {
    new Test[U](v)
  }
}

我们可以看到生物、人和员工之间的层次结构关系：

Creature <- Person <- Employee

在 def main 中：

val test = new Test[Person]()
val ub = test.upperBound(new Employee("John Derp")) //#1 ok because Employee is subtype of Person
val lb = test.lowerBound(new Creature())            //#2 ok because Creature is supertype of Person
val ub2 = test.upperBound(new Creature())           //#3 error because Creature is not subtype of Person
val lb2 = test.lowerBound(new Employee("Scala Jo")) //#4 ok? how could? as Employee is not supertype of Person

我能理解的是：

1. A <: B定义 A 必须是子类型或等于 B(上限(

2. A >: B定义 A 必须是超类型或等于 B(下限(

但是#4发生了什么？为什么没有错误？由于员工不是 Person 的超类型，我希望它不应该符合绑定类型参数 [U >: T] 。

任何人都可以解释吗？

Answer 1

这个例子可能会有所帮助

scala> test.lowerBound(new Employee("Scala Jo"))
res9: Test[Person] = Test@1ba319a7
scala> test.lowerBound[Employee](new Employee("Scala Jo"))
<console>:21: error: type arguments [Employee] do not conform to method lowerBound's type parameter bounds [U >: Person]
              test.lowerBound[Employee](new Employee("Scala Jo"))
                             ^

一般来说，它与 Liskov 替换原理有关 - 你可以在任何地方使用子类型而不是超类型(或"子类型总是可以强制转换为其超类型"(，因此类型推断试图推断尽可能接近的超类型(就像这里Person

(。

因此，对于 ub2 来说，[Nothing..Person] 和 [Creature..Any] 之间没有这样的交集，但对于 lb2，[Person..Any] 和 [Employee..Any] 之间有一个 - 这就是Person。因此，您应该显式指定类型(强制Employee而不是[Employee..Any](，以避免此处的类型推断。

即使使用类型推断，lb2 也会预期失败的示例：

scala> def aaa[T, A >: T](a: A)(t: T, a2: A) = t
aaa: [T, A >: T](a: A)(t: T, a2: A)T
scala> aaa(new Employee(""))(new Person(""), new Employee(""))
<console>:19: error: type arguments [Person,Employee] do not conform to method aaa's type parameter bounds [T,A >: T]
              aaa(new Employee(""))(new Person(""), new Employee(""))
              ^

在这里，类型 A 在第一个参数列表中推断并固定为 Employee ，因此第二个参数列表(抛出错误(只有选择 - 按原样使用它。

或最常用的具有不变O[T]的示例：

scala> case class O[T](a: T)
defined class O
scala> def aaa[T, A >: T](t: T, a2: O[A]) = t
aaa: [T, A >: T](t: T, a2: O[A])T
scala> aaa(new Person(""), O(new Employee("")))
<console>:21: error: type mismatch;
 found   : O[Employee]
 required: O[Person]
Note: Employee <: Person, but class O is invariant in type T.
You may wish to define T as +T instead. (SLS 4.5)
              aaa(new Person(""), O(new Employee("")))
                                   ^

T在此处固定为Employee，无法将O[Employee]转换为 默认情况下，由于不变性O[Person]。

Answer 2

我认为这是因为您可以将任何Person传递给您的

Test[Person].lowerBound(Person)

由于Employee是Person的一个子类，因此它被认为是Person在这里是合法的。