协变类型 FParam 出现在值猜测的类型 Seq[FParam] 中的逆变位置

Question

考虑这个简单的例子：

trait Optimizer[+FParam, FRes] {
  def optimize(
    fn: (FParam) => FRes,
    guesses: Seq[FParam] // <--- error
  )
}

它不能编译，因为

协变类型FParam出现在值猜测的类型Seq[FParam]中的逆变位置。

但是 seq 被定义为trait Seq[+A] ，那么这种逆变的来源是什么？ （问题一）

相反，请考虑这个带有-FParam简单示例：

trait Optimizer[-FParam, FRes] {
  def optimize(
    fn: (FParam) => FRes, // <--- error
    guesses: Seq[FParam]
  )
}

逆变类型出现在类型(FParam) => FRes中的协变位置

同样，同样的悖论：在Function1[-T1, R] ，第一个类型参数显然是逆变的，那么为什么FParam处于协变位置？ (问题2 )

我可以通过翻转下类型边界中描述的方差来解决这个问题，但不清楚为什么有必要。

trait Optimizer[+FParam, FRes] {
  type U <: FParam

  def optimize(
    fn: (FParam) => FRes,
    guesses: Seq[U]
  )
}

Answer 1

问题 1 ： +FParam表示协变类型FParam并且它从超类型到子类型FParam 。 对于guesses它期望Seq的cotravariant type 。 因此，您可以通过为此显式声明FPParam的supertype来实现，例如：

def optimize[B >: FParam](fn: (B) => FRes, guesses: Seq[B]) // B is the super type of FParam

或者像SeqViewLike 。

那么为什么guesses它期望Seq的cotravariant type ？ 例如：

trait Animal

case class Dog() extends Animal

case class Cat() extends Animal
val o = new Optimizer2[Dog, Any]
val f: Dog => Any = (d: Dog) =>  ...
o.optimize(f, List(Dog(), Cat())) // if we don't bind B in `guesses` for supertype of `FParam`, it will fail in compile time, since the `guesses` it's expecting a `Dog` type, not the `Animal` type. when we bind it to the supertype of `Dog`, the compiler will infer it to `Animal` type, so `cotravariant type` for `Animal`, the `Cat` type is also matched.

问题 2 ： -FParam表示协变类型FParam ，它从超类型FParam到它的子类型.for fn: Function1[-T1, +R]//(FParam) => FRes它期望协变类型。 因此，您可以通过反转问题 1类型的状态来实现，例如：

def optimize[B <: FParam](fn: (B) => FRes, guesses: Seq[B]) // B is the sub type of FParam

Answer 2

问题是 FParam 不是直接使用的。 它在optimize的参数中，因此它的方差被翻转。 为了说明，让我们看一下optimize的类型（参见val optim ）：

trait Optimizer[+FParam, FRes] {
  type U <: FParam

  def optimize(
    fn: (FParam) => FRes,
    guesses: Seq[U]
  )

  val optim: Function2[
    Function1[
      FParam,
      FRes
    ],
    Seq[U],
    Unit
  ] = optimize
}

Answer 3

刚刚解决了这个问题，希望我能解决这个困惑。

Seq[] 不是列表，并且其中不能同时包含一种以上的类类型。 你的特征优化器有一个未知但固定的类 FParam 或一个子类，但你的函数返回一个 Seq[FParam] 并不一定是与封闭对象相同的子类。 因此，运行时可能会同时在 Seq[FParam] 中结束不同的子类，因此整个代码块成为 Scala 编译错误。

abstract class Optimizer[+FParam, FRes] {

}

object Optimizer{
   def optimize[FParam,FRes](obj: Optimizer[FParam,FRes], param : FParam) : (FParam,Seq[FParam]) = (param,(Nil)) 
}

trait（现在是一个抽象类）仍然具有协变泛型参数，但是在其参数中使用协变泛型的函数被类型锁定为具有不变量的精确类型 - 现在在单例对象中强制使用函数中的相同类或子类。