Scala：在路径相关上下文中重用路径相关类型产生的泛型

简而言之：以下内容无法编译（原因如下），我怎样才能使其工作？

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 hides T-具体行为来自SimIterator后者处理常见任务。S用于强制值CMH拥有正确的类型而无需实例Simulator.

In the foreach，似乎存在与以下相关的子类型问题CM. If 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?

UPDATE

这可以工作，但不能在构造函数中使用（非法依赖方法类型：参数出现在同一部分或较早部分中另一个参数的类型中）

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

上面的例子可以工作，但是not我想要的是。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 保留为类型成员，请提供更多详细信息，解释在哪种情况下您需要类型投影以及原因。

编辑/更新

欢迎来到“末日面包店”！ ;-)

这种情况有两种解决方案：

1st, 把你的迭代器放进蛋糕里，因此您可以直接访问该类型：

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) }
  }
}

or 2nd, 将迭代器封装在另一个类中，使得访问路径相关类型成为可能：

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) }
  }
}

一旦陷入蛋糕，就无法逃脱！