使用不可变集合的上限

Question

我正在尝试创建一个可以采用immutable.Seq 的任何后代的类型参数的方法。这是我到目前为止得到的：

def writeSomeData[Holder[_] <: Seq[String]](path: String, holder: Holder[String]): Unit = {
// irrelevant implementation
  }

但是，当我使用immutable.List 调用上述方法时：

writeSomeData(tmp, List(res1, res2, res3, res4, res5))

它因以下错误而中断：

[error] /home/v.gorcinschi/repos/...: inferred type arguments [List] do not conform to method writeSomeData's type parameter bounds [Holder[_] <: Seq[String]]
[error]       writeSomeData(tmp, List(res1, res2, res3, res4, res5))
[error]       ^
[error] /home/v.gorcinschi/repos/...: type mismatch;
[error]  found   : List[String]
[error]  required: Holder[String]
[error]       writeSomeData(tmp, List(res1, res2, res3, res4, res5))

为什么会发生这种情况，我必须如何纠正它？ List 不是 Seq 的后代吗？

Answer 1

问题是Holder[_] <: Seq[String] 并不代表你认为的那样。我实际上不确定它是什么意思，可能类似于：trait Holder[A] extends Seq[String]，正如您所看到的，它与 List 的样子非常不同。

您实际上想表达Holder[String] 应该是Seq[String] 的子类型许多人认为正确的语法是Holder[_] <: Seq[_] 但是，这也是不正确的；这只是意味着 Holder 必须扩展 Seq 但不保证 Holder[String] <: Seq[String]
值得庆幸的是，Scala 确实提供了语法来表示：Holder[x] <: Seq[x] x 不是另一个类型参数，这只是表示 Holder[x] 是任何类型的 Seq[x] 的子类型x

有时，您还可以更轻松地使用通用类型约束，例如：

def foo[Holder[_]](holder: Holder[String])(implicit ev: Holder[String] <:< Seq[String]): Unit

表示完全相同的关系。

---

不过，只有在返回类型中引用 Holder 时才有用，如果您只想使用任何 Seq，那么您可以这样做：

def foo(holder: Seq[String]): Unit

感谢 Liskov，您可以在那里传递 Seq[String] 的任何子类型。

Answer 2

类型约束

Holder[_] <: Seq[String]

表示方法采用任何类型的构造函数Holder，使得Holder[X] 是任意X 的Seq[String] 的子类型。任意指的是X >: Nothing <: Any。

现在，当您将 List("") 作为参数传递时，Scala 将尝试统一

?Holder := List

这样Holder[X] <: Seq[String] 代表任意X。但是List[X] 不是Seq[String] 的子类型，用于任意X，例如采用X := Int。因此它不输入检查。

作为一种解决方法，我们可以做

Holder[x <: String] <: Seq[x]

这有效地实现了同样的目标，但这次它起作用了，因为现在

Holder[x] <: Seq[x]

确实适用于任意 x，因为 List 和 Seq 的定义相似

trait Seq[+A]
trait List[+A]

确实[X] =>> List[X] <:>[X] =>> Seq[X] 为任意x。

Plus 编译器有来自Holder[x <: String] 的额外信息x <: String 来检查参数的元素类型。

给定

Holder[_] <: Seq[String]

您可以通过帮助编译器显式传递适当的类型 lambda 来使其工作

writeSomeData[[X] =>> List[String]](???, List(""))

但我认为 Scala 不会自动推断此类 lambda，因为通常类型构造函数统一为 undecidable。