我可以使用Typeclasses获得非混合子类，共享联合收割机的实现以及返回子类类型吗？

Question

猫和狗都是宠物，因此有一个年龄。我想定义一个选择方法，给定两只猫或两只狗，都会选择最古老的宠物，但是当cat 和同时选择哪种宠物出现狗。

用类型的半群似乎使我在那里的90％，但我无法弄清楚是否可以定义selectOldest 一旦从理论上讲，由于所有pet s都有一个年龄，因此不需要为每个pet实现它仍然返回子类的类型并保留“猫和狗不混合”规则：

trait Pet {
  def age: Int

  // When implementation is shared, it *doesn't* return the subclass type
  def _chooseOldest(rhs: Pet): Pet = if (age > rhs.age) this else rhs
}

case class Dog(age: Int) extends Pet
case class Cat(age: Int) extends Pet

trait Semigroup[A] {
  def chooseOldest(lhs: A, rhs: A): A
}

// When the implementation returns the subclass type, it can't be shared
implicit val dogSemigroup = new Semigroup[Dog] {
  override def chooseOldest(lhs: Dog, rhs: Dog): Dog = if (lhs.age > rhs.age) lhs else rhs
}

implicit val catSemigroup = new Semigroup[Cat] {
  override def chooseOldest(lhs: Cat, rhs: Cat): Cat = if (lhs.age > rhs.age) lhs else rhs
}

def chooseGeneric[P <: Pet](p1: P, p2: P)(implicit ev: Semigroup[P]): P = ev.chooseOldest(p1, p2)

def canChooseDogs(d1: Dog, d2: Dog)(implicit ev: Semigroup[Dog]): Dog = chooseGeneric(d1, d2)(ev)
def canChooseCats(c1: Cat, c2: Cat)(implicit ev: Semigroup[Cat]): Cat = chooseGeneric(c1, c2)(ev)

// Appropriately errors because there is no Semigroup[Pet]
def cantMixCatsAndDogs(c: Cat, d: Dog)(implicit ev: Semigroup[Pet]): Pet = chooseGeneric(c, d)(ev)

如果我不知道这一点，我将尝试 f-bond-bond-bond-bond-bond-bond-typer-typermormormist 仅仅因为这是我第一次进入类型类。

是否可以使用TypeClasses实现3个给定的要求？

1. 猫和狗不能“合并”
2. selectoldest有一个实现
3. ，那里存在selectOldest，它返回 sublellages type

Answer 1

您可以做到这一点：

sealed trait Pet {
  def age: Int
}
object Pet {
  final case class Dog(age: Int) extends Pet
  final case class Cat(age: Int) extends Pet

  sealed trait ChooseOldest[P <: Pet] {
    def apply(p1: P, p2: P): P
  }
  object ChooseOldest {
    given instance[P <: Pet](using NotGiven[P =:= Pet]): ChooseOldest[P] with
      override def apply(p1: P, p2: P): P =
        if (p1.age > p2.age) p1 else p2
  }
  
  extension [P <: Pet](self: P)(using ev: ChooseOldest[P])
    def chooseOldest(other: P): P =
      ev(self, other)
}

请注意，notgiven [p =：= pet]是确保不会有允许混合类型的实例。