根据类型类设置抽象类型

我有一个这样的例子：

abstract class IsBaseTC[A] { type Self }
abstract class JustHoldsTypeMember[A] extends IsBaseTC[A] 
implicit val doubleHoldsTypeMember = new JustHoldsTypeMember[Double] { type Self = Double }

abstract class IsActualTC[A, T](implicit val aIsBaseTc: IsBaseTC[T]) extends IsBaseTC {
  type Self = A
  def get(self: A): aIsBaseTc.Self
}

case class Container[T](
  get: T
)

implicit val containerOfDoubleIsActual = new IsActualTC[Container[Double], Double] {
  def get(self: Self) = self.get // type mismatch; 
                                  // found self.get.type (with underlying type Double) 
                                  // required this.aIsBaseTc.self
}

这给了我上面显示的错误。除非我没能正确遵循自己的逻辑，this.aIsBaseTc.self应解决Double。有没有办法让编译器相信是这种情况？

感谢您的任何帮助。

事情在范围内。

更简单的例子是

trait A { type T }
implicit val a: A { type T = Int } = null
def test(implicit x: A): Unit = {
  implicitly[x.T =:= Int] // doesn't compile, cannot prove that x.T =:= Int
}

你假设x is a (aIsBaseTc is doubleHoldsTypeMember在你的注释中）。但实际上x is not a, x将在何时解决test被称为（在范围内test调用站点）但是a是在当前范围内定义的（范围test定义）。相似地，aIsBaseTc is not doubleHoldsTypeMember.

当使用类型参数进行隐式解析时，为什么 val 放置很重要？（参见之间的区别implicit x: X and implicitly[X].)

对于任何匿名类

implicit val containerOfDoubleIsActual = new IsActualTC[Container[Double], Double] {
  def get(self: Self) = self.get // type mismatch; 
}

是一个简写

class IsActualTCImpl extends IsActualTC[Container[Double], Double] {
  def get(self: Self) = self.get // type mismatch; 
                                 // aIsBaseTc is not doubleHoldsTypeMember here
}
implicit val containerOfDoubleIsActual = 
  new IsActualTCImpl // implicit is resolved here
                     // aIsBaseTc becomes doubleHoldsTypeMember here

自从aIsBaseTc is not doubleHoldsTypeMember, aIsBaseTc.Self is not Double.

可能的修复方法是再添加一个类型参数S to IsActualTC

abstract class IsActualTC[A, T, S](implicit val aIsBaseTc: IsBaseTC[T] {type Self = S}) extends IsBaseTC {
  type Self = A
  def get(self: A): S
}

implicit val containerOfDoubleIsActual = new IsActualTC[Container[Double], Double, Double] {
  def get(self: Self) = self.get
}

或向隐式参数添加类型细化IsActualTC

abstract class IsActualTC[A, T](implicit val aIsBaseTc: IsBaseTC[T] {type Self = T}) extends IsBaseTC {
  type Self = A
  def get(self: A): aIsBaseTc.Self
}

implicit val containerOfDoubleIsActual = new IsActualTC[Container[Double], Double] {
  def get(self: Self) = self.get
}