使用动态/具体类型初始化类型变量

我正在学习 Scala，我试图创建一个类型类来解决“每种动物都吃食物，但食物的类型取决于动物”的问题。我有一个Eats具有上下文边界的类型类：

trait Eats[A <: Animal, B <: Edible]

object Eats {
    def apply[A, B]: Eats[A, B] = new Eats[A, B] {}
}

既Animal and Edible是抽象类。 （减少）Animal界面看起来像这样

abstract class Animal {
    type This // concrete type
    def eat[A <: Edible](food: A)(implicit e: Eats[This, B]) = // ...
}

我的目标是允许以下形式的调用animal.eat(food)仅当存在给定类型的动物和食物的实例（范围内的隐式值）时。为此我创建了一个EatingBehaviour对象基本上包含所有关系的实例。例如为了声明牛吃草，我添加了这一行

implicit val cowEatsGrass = Eats[Cow, Grass]

类似于你会怎么写instance Eats Cow Grass在哈斯克尔。但是，现在我需要指定抽象类型This对于 Animal 类的所有子类型的签名Animal工作界面：

class Cow extends Animal { type This = Cow }

这是多余的。

因此我的问题：我可以以某种方式初始化类型变量吗This in Animal这样它总是反映具体类型，类似于我如何使用动态类型getClass?

如果传递第一个操作数，则不会出现该问题a: A到有机会推断外部可见类型的方法/类构造函数A:

trait Animal
trait Eats[A <: Animal, B <: Animal]

object Eats {
    def apply[A <: Animal, B <: Animal]: Eats[A, B] = new Eats[A, B] {}
}

implicit class EatsOps[A <: Animal](a: A) {
    def eat[B <: Animal](food: B)(implicit e: Eats[A, B]) = 
      printf(s"%s eats %s\n", a, food)
}

case class Cat() extends Animal
case class Bird() extends Animal
case class Worm() extends Animal

implicit val e1 = Eats[Cat, Bird]
implicit val e2 = Eats[Bird, Worm]

val cat = Cat()
val bird = Bird()
val worm = Worm()

// c eat c // nope
cat eat bird
// c eat w // nope

// b eat c // nope
// b eat b // nope
bird eat worm 

// w eat c // nope
// w eat b // nope
// w eat w // nope

Here, EatsOps[A <: Animal]可以先推断出什么A是，那么在eat[B <: Animal]它可以推断出什么B是，并使用有关两者的信息A and B插入正确的隐式。没有类型成员，扩展时无需执行任何操作Animal.

这有点像 XY 问题的 X 解决方案。是的，我重复使用了Animal代替Food...

Update

如果你想访问某个特定的私有方法Animal调用时执行eat，通常的方法是将所有基本功能移至Eats特征，然后提供实例Eats在特定的伴随对象中Animal。例如，我们可以这样让Cat做它不可思议的事private在真正吃之前的东西Bird:

trait Eats[A <: Animal, B <: Animal] {
  def apply(a: A, food: B): Unit
}

object Eats {
    def apply[A <: Animal, B <: Animal]: Eats[A, B] = new Eats[A, B] {
      def apply(animal: A, food: B) = println(s"${animal} eats ${food}")
    }
}

implicit class EatsOps[A <: Animal](animal: A) {
    def eat[B <: Animal](food: B)(implicit e: Eats[A, B]) = e(animal, food)
}

case class Cat() extends Animal {
  private def privateCatMethod(b: Bird): Unit = {}
}

object Cat {
  implicit val catsEatBirds: Eats[Cat, Bird] = new Eats[Cat, Bird] {
    def apply(c: Cat, b: Bird): Unit = {
      c.privateCatMethod(b)
      println(s"{c} eats {b}")
    }
  }
}

其余代码将保持不变，只是不需要e1: Eats[Cat, Bird]不再有。