如何避免具有多个类型类关系的模棱两可的转换链？

Question

在我的库中，我有三个类型类：

trait Monoid[T] {
  val zero : T
  def sum(x : T, y : T) : T
}

trait AbelianGroup[T] extends Monoid[T] {
  def inverse(x : T) : T
  def difference(x : T, y : T) : T
}

//represents types that are represents lists with a fixed number of elements, such as
//the tuple type (Int, Int)
trait Vector[T, U] {
  ...
}

这些类型类在以下条件下可以相互转换：

• 如果T 类型是scala.math.Numeric 类型，那么它也是AbelianGroup。
• 如果T 类型是AbelianGroup，它也是Monoid（目前，AbelianGroup 扩展Monoid，但不一定是这种情况）
• 如果T 类型是U 类型的Vector，并且U 类型是Monoid，那么T 类型也是Monoid。
• 如果类型 T 是类型 U 上的 Vector，类型 U 是 AbelianGroup，则 T 也是 AbelianGroup。

例如，由于(Int, Int) 是Int 类型上的Vector，而Int 是AbelianGroup，那么(Int, Int) 也是AbelianGroup。

这些关系和其他关系很容易在伴随类中实现，如下所示：

object Monoid {
  implicit def fromAbelianGroup[T : AbelianGroup] : Monoid[T] = implicitly[AbelianGroup[T]]
  implicit def fromVector[T : Vector[T, U], U : Monoid] : Monid[T] = ...
}

object AbelianGroup {
  implicit def fromNumeric[T : Numeric] : AbelianGroup[T] = ...
  implicit def fromOtherTypeX[T : ...] : AbelianGroup[T]
  ...
  implicit def fromVector[T : Vector[T, U], U : AbelianGroup] : AbelianGroup[T] = ...
}

在您尝试使用元组类型 (Int, Int) 之类的东西作为 Monoid 之前，这非常有效。编译器找到两种方法来获取此类类型的 Monoid 类型类对象：

1. Monoid.fromAbelianGroup(AbelianGroup.fromVector(Vector.from2Tuple, AbelianGroup.fromNumeric))

2. Monoid.fromVector(Vector.from2Tuple, Monid.fromAbelianGroup(AbelianGroup.fromNumeric))

为了解决这种歧义，我修改了 Monoid 伴随类以包含从 Numeric 的直接转换（以及其他可直接转换为 AbelianGroup 的类型）。

/*revised*/
object Monoid {
  //implicit def fromAbelianGroup[T : AbelianGroup] : Monoid[T] = implicitly[AbelianGroup[T]]
  implicit def fromNumeric[T : Numeric] : Monoid[T] = ... //<-- redundant
  implicit def fromOtherTypeX[T : ...] : AbelianGroup[T] = ... //<-- redundant
  ...
  implicit def fromVector[T : Vector[T, U], U : Monoid] : Monid[T] = ...
}

object AbelianGroup {
  implicit def fromNumeric[T : Numeric] : AbelianGroup[T] = ...
  implicit def fromOtherTypeX[T : ...] : AbelianGroup[T] = ...
  ...
  implicit def fromVector[T : Vector[T, U], U : AbelianGroup] : AbelianGroup[T] = ...
}

但是，这有点令人不满意，因为它本质上违反了 DRY 原则。当我为AbelianGroups 添加新实现时，我必须在两个伴随对象中实现转换，就像我为Numeric 和OtherTypeX 等所做的那样。所以，我觉得我在某个地方走错了方向.

有没有办法修改我的代码以避免这种冗余并解决编译时歧义错误？在这种情况下，最佳做法是什么？

Answer 1

你可以move the implicits for which you want to have lower priority into a supertype of the companion object:

trait LowPriorityMonoidImplicits {
  implicit def fromVector[T : Vector[T, U], U : Monoid] : Monoid[T] = ...
}

object Monoid extends LowPriorityMonoidImplicits  {
  implicit def fromAbelianGroup[T : AbelianGroup] : Monoid[T] = implicitly[AbelianGroup[T]]
}