Pattern matching for abstracted case classes 抽象化的case类的模式匹配

我正在尝试使用依赖方法类型和编译器的夜间版本（2.10.0.r26005-b20111114020239）在一个模块中抽象案例类。我从Miles Sabin的例子中找到了一些灵感。

我真的不明白下面的（自包含的）代码中有什么问题。输出结果取决于foo中模式的顺序。

//据我所知，编译器不公开伴生对象的unapply方法
// for a companion object
trait Isomorphic[A, B] {
  def apply(x: A): B
  def unapply(x: B): Option[A]
}
//抽象模块
trait Module {
  // 3个带有一些约束的类型
  type X
  type Y <: X
  type Z <: X
  // 以及它们的"伴生"对象
  def X: Isomorphic[Int, X]
  def Y: Isomorphic[X, Y]
  def Z: Isomorphic[Y, Z]
}
//一个依赖于案例类的实现
object ConcreteModule extends Module {
  sealed trait X { val i: Int = 42 }
  object X extends Isomorphic[Int, X] {
    def apply(_s: Int): X = new X { }
    def unapply(x: X): Option[Int] = Some(x.i)
  }
  case class Y(x: X) extends X
  // 我猜编译器可以为我完成这个
  object Y extends Isomorphic[X, Y]
  case class Z(y: Y) extends X
  object Z extends Isomorphic[Y, Z]
}
object Main {
  def foo(t: Module)(x: t.X): Unit = {
    import t._
    // 输出结果取决于前三行的顺序
    // 我不确定这里发生了什么...
    x match {
      //未经检查，因为被擦除
      case Y(_y) => println("y "+_y)
      //未经检查，因为被擦除
      case Z(_z) => println("z "+_z)
      //这个没问题
      case X(_x) => println("x "+_x)
      case xyz => println("xyz "+xyz)
    }
  }
  def bar(t: Module): Unit = {
    import t._
    val x: X = X(42)
    val y: Y = Y(x)
    val z: Z = Z(y)
    foo(t)(x)
    foo(t)(y)
    foo(t)(z)
  }
  def main(args: Array[String]) = {
    //使用具体模块调用bar
    bar(ConcreteModule)
  }
}

有什么想法吗？