scala - Scala : Re-use generic resulting from path-dependent type in path-dependent context

简而言之:以下内容无法编译(原因如下)，如何使它起作用？

trait Simulator {
  type CM[T]
  def useCM(v: CM[_])
}

case class CMH[S <: Simulator,T](cm: S#CM[T])

class SimIterator[S <: Simulator](val sim: S, val cmhs: Seq[CMH[S,_]]) {
  cmhs foreach { cmh => sim.useCM(cmh.cm) }
  /*
  compile time error:
   type mismatch; found : cmh.cm.type (with underlying type S#CM[_$2]) required:
   SimIterator.this.sim.CM[_] Note: _$2 <: Any (and cmh.cm.type <: S#CM[_$2]),
   but type CM is invariant in type T. You may wish to define T as +T instead.
   (SLS 4.5)
  */
}

该结构背后的思想是CMH在T中隐藏了SimIterator特定的行为，而后者则负责处理常见任务。 S用于强制CMH中的vlaues具有正确的类型，而无需Simulator的实例。

在foreach中，似乎存在与CM相关的子类型问题。如果S#CM是具体类型，则需要sim.CM =:= S#CM。但是，请看以下内容:

object Test extends Simulator {
  type CM[T] = Option[T]
  def useCM(v: CM[_]) = println(v)
  def mkCM[T]: CM[T] = None

  CMH[Simulator,AnyRef](mkCM[AnyRef])
}

现在我们有了一个CMH，我们可以将它与任何SimIterator一起传递到Simulator中。因此，显然SimIterator的键入不够严格。如何表达(和使用)S =:= sim.type？

更新

此方法有效，但不能在构造函数中使用(非法的依赖方法类型:参数以同一节或更早版本中的另一个参数的类型出现)

class SimIterator(val sim: Simulator) {
  def doIt(cmhs: Seq[CMH[sim.type,_]]) {
    cmhs foreach { cmh => sim.useCM(cmh.cm) }
  }
}

上面的示例有效，但是不是我想要的。 cmhs应该在构造时传递。

最佳答案

您可以通过将抽象类型成员移动到这样的类型参数来轻松解决此问题:

trait Simulator[CM[_]] {
  def useCM(v: CM[_])
}

case class CMH[CM[_]](cm: CM[_])

class SimIterator[S <: Simulator[CM], CM[_]](val sim: S, val cmhs: Seq[CMH[CM]]) {
  cmhs foreach { cmh => sim.useCM(cmh.cm) }
}

这样可以避免使用类型投影，如果您确实需要保持CM为类型成员，请提供更多详细信息，以说明在哪种情况下需要类型投影以及原因。

编辑/更新

欢迎来到“厄运面包房”! ;-)

在这种情况下，有两种解决方案:

1，将您的Iterator放入蛋糕，因此您可以直接访问类型:

case class CMH[CM[_]](cm: CM[_])

trait Cake {
  type CM[_]

  trait Simulator {
    def useCM(v: CM[_])
  }

  class SimIterator[S <: Simulator](val sim: S, val cmhs: Seq[CMH[CM]]) {
    cmhs foreach { cmh => sim.useCM(cmh.cm) }
  }
}

或第二，将您的Iterator封装在另一个类中，从而可以访问依赖于路径的类型:

trait Cake {
  type CM[_]

  trait Simulator {
    def useCM(v: CM[_])
  }
}

case class CMH[CM[_]](cm: CM[_])

class SimIteratorBuilder[C <: Cake](val cake: Cake) {
  class SimIterator(val sim: cake.Simulator, val cmhs: Seq[CMH[cake.CM]]) {
    cmhs foreach { cmh => sim.useCM(cmh.cm) }
  }
}

一旦进入蛋糕，就无法逃脱!