类型差异的问题

Question

所以，假设我有一个带有逆变类型参数的类：

  trait Storage[-T] {
    def list(path: String): Seq[String]
    def getObject[R <: T](path: String): Future[R]
  }

类型参数的想法是将实现限制在它可以返回的类型的上限。所以，Storage[Any] 可以读取任何内容，而Storage[avro.SpecificRecord] 可以读取 avro 记录，但不能读取其他类：

def storage: Storage[avro.SpecificRecord] 
storage.getObject[MyAvroDoc]("foo") // works
storage.getObject[String]("bar") // fails

现在，我有一个实用程序类，可用于遍历给定位置的对象：

class StorageIterator[+T](
  val storage: Storage[_ >: T], 
  location: String
)(filter: String => Boolean) extends AbstractIterator[Future[T]] {
  val it = storage.list(location).filter(filter)
  def hasNext = it.hasNext
  def next = storage.getObject[T](it.next)
}

这可行，但有时我需要从下游迭代器访问底层storage，以从辅助位置读取另一种类型的对象：

def storage: Storage[avro.SpecificRecord]
val iter = new StorageIterator[MyAvroDoc]("foo")
iter.storage.getObject[AuxAvroDoc](aux)

这当然行不通，因为storage类型参数是通配符，没有证据证明可以用来读取AuxAvroDoc

我尝试这样修复它：

class StorageIterator2[P, +T <: P](storage: Storage[P])
  extends StorageIterator[T](storage)

这可行，但现在我必须在创建它时指定两个类型参数，这很糟糕:( 我试图通过向Storage 本身添加一个方法来解决它：

trait Storage[-T] {
  ... 
  def iterate[R <: T](path: String) = 
    new StorageIterator2[T, R](this, path)
}

但这不会编译，因为它将T 置于一个不变的位置:( 如果我使P 逆变，那么StorageIterator2[-P, +T <: P] 失败，因为它认为P occurs in covariant position in type P of value T。

最后一个错误我不明白。为什么 P 在这里不能逆变？如果这个位置真的是协变的（为什么会这样？）那么为什么它允许我在那里指定一个不变的参数呢？

最后，有人知道我该如何解决这个问题吗？ 基本上，这个想法是能够

1. 做storage.iterate[MyAvroDoc]而不必再次给它上边界，并且
2. 执行iterator.storage.getObject[AnotherAvroDoc] 无需强制转换存储以证明它可以读取此类对象。

感谢任何想法。

Answer 1

StorageIterator2[-P, +T <: P] 失败，因为它是无意义的。如果你有一个StorageIterator2[Foo, Bar]和Bar <: Foo，那么因为它在第一个参数中是逆变的，所以它也是一个StorageIterator[Nothing, Bar]，但是Nothing没有子类型，所以逻辑上不可能Bar <: Nothing，然而这就是拥有StorageIterator2 的必要条件。因此，StorageIterator2 不能存在。

根本问题是Storage 不应该是逆变的。想一想Storage[T] 是，就它提供给用户的合同而言。 Storage[T] 是您提供路径的对象，并将输出 Ts。 Storage 是协变的非常有意义：例如，知道如何输出 Strings 的东西也在输出 Anys，所以 Storage[String] <: Storage[Any] 是合乎逻辑的。你说它应该是相反的，Storage[T] 应该知道如何输出T 的任何子类型，但那将如何工作？如果有人在事后向T 添加子类型怎么办？ T 甚至可以是 final 并且仍然存在这个问题，因为单例类型。这是不必要的复杂，并反映在您的问题中。也就是Storage应该是

trait Storage[+T] {
  def list(path: String]: Seq[String]
  def get(path: String): T
}

这不会让您看到您在问题中给出的示例错误：

val x: Storage[avro.SpecificRecord] = ???
x.get(???): avro.SpecificRecord // ok
x.get(???): String // nope
(x: Storage[String]).get(???) // nope

现在，你的问题是你不能做像storage.getObject[T] 这样的事情并且让演员表是隐式的。你可以改为match:

storage.getObject(path) match {
  case value: CorrectType => ...
  case _ => // Oops, something else. Error?
}

一个普通的asInstanceOf（不受欢迎），或者您可以向Storage 添加一个辅助方法，就像您之前使用的那样：

def getCast[U <: T](path: String)(implicit tag: ClassTag[U]): Option[U] = tag.unapply(get(path))