上限类型限制允许子类型但不允许父类型

Question

是否可以有一个泛型方法，其类型绑定相当于“此特征的每个可能的具体子类，但不是特征本身？”

例如，假设我有以下继承层次：

sealed trait Fruit

case class Apple() extends Fruit
case class Orange() extends Fruit
...
case class Watermelon() extends Fruit

我想定义一个方法def eatFruit[T <: ???](fruit: Seq[T])，它允许T 是Apple、Orange、Watermelon 等类型，但不是Fruit 类型。类型绑定[T <: Fruit] 显然不能胜任。

最初的动力是我们有一个FruitRepository 类，它允许批量/批量插入不同的水果。批处理是在类外部完成的，因此目前它有很多类似于saveApples(apples: Seq[Apple])、saveOranges(oranges: Seq[Orange]) 等的方法，其中包含很多涉及创建批处理更新语句的重复逻辑。我想以更通用的方式管理它，但任何方法 saveFruit(fruit: Seq[Fruit]) 都允许例如包含苹果和橙子的列表，存储库无法处理。

...我也承认，我现在通常对这种类型绑定是否可能感到好奇，即使我们最终以不同的方式解决了存储库问题。

Answer 1

我们可以将上限指令与类型不等式的自定义隐式强制结合起来。 Taken from here（或一般见：Enforce type difference）：

@annotation.implicitNotFound(msg = "Cannot prove that ${A} =!= ${B}.")
trait =!=[A, B]
object =!= {
  class Impl[A, B]
  object Impl {
    implicit def neq[A, B] : A Impl B = null
    implicit def neqAmbig1[A] : A Impl A = null
    implicit def neqAmbig2[A] : A Impl A = null
  }

  implicit def foo[A, B](implicit e: A Impl B): A =!= B = null
}

然后我们这样做：

def eatFruit[T <: Fruit](implicit ev: T =!= Fruit) = ???

当我们调用它时：

def main(args: Array[String]): Unit = {
  eatFruit[Fruit]
}

我们得到：

Error:(29, 13) Cannot prove that yuval.tests.FooBar.Fruit =!= yuval.tests.FooBar.Fruit.
    eatFruit[Fruit]

但这编译：

eatFruit[Orange]

这里的所有魔力都是由于在 [A, A] 对的范围内创建了隐含的歧义，以至于编译器会抱怨。

---

我们还可以更进一步，实现我们自己的逻辑类型，例如，我们称之为=<:=!=。我们可以稍微改变一下之前的实现：

@annotation.implicitNotFound(msg = "Cannot prove that ${A} =<:=!= ${B}.")
trait =<:=!=[A,B]
object =<:=!= {
  class Impl[A, B]
  object Impl {
    implicit def subtypeneq[B, A <: B] : A Impl B = null
    implicit def subneqAmbig1[A] : A Impl A = null
    implicit def subneqAmbig2[A] : A Impl A = null
  }

  implicit def foo[A, B](implicit e: A Impl B): A =<:=!= B = null
}

现在：

case class Blue()

def main(args: Array[String]): Unit = {
  eatFruit[Fruit] // Doesn't compile
  eatFruit[Blue] // Doesn't compile
  eatFruit[Orange] // Compiles
}