Scala 与路径投影的混淆

这就是我要做的

class Bar[P](val x: P) { type Foo = P }
class Baz[R <: Bar[_]](bar: R) { val x: R#Foo = bar.x }

听起来“底层类型$1”正是我在这里想要的，但这并不能编译。 有什么办法可以满足我的要求吗

更新

也许，我过于简化了用例。 比如说，

Bar

实际上是这样的：

trait Foo[T] { def doStuff(t: T) = ??? }
class Bar[P] extends Foo[P](val x: P) { type Foo = P }

在别的地方我有一个

 def fooX[T](x: T, foo: Foo[T]) = foo.doStuff(x)

我想从

Baz

调用它：

 class Baz[R <: Bar[_]](bar: R) { fooX(bar.x, bar) }

class Baz[R当调用
fooX（bar.x，bar）
时，编译器只看到：


bar:bar[\u]
这与某些{type X}的
bar:bar[X]相同
bar.x:x对于某些{type x}
，它减少为
bar.x:Any

然后，对于某些{type X}

，它无法证明

Any

与

中的
X
相同。但是，如果将未知类型绑定到变量
p
，编译器会看到：


bar:bar[p]
bar.x:p
fooX[p]（bar.x，bar）
适用

因此，这项工作：

trait Foo[T] { def doStuff(t: T) = ??? }
class Bar[P](val x: P) extends Foo[P] { type Foo = P }

def fooX[T](x: T, foo: Foo[T]) = foo.doStuff(x)

class Baz[R <: Bar[_]](bar: R){
  bar match {
    case b: Bar[p] => fooX[p](b.x, b)
  }
}

我想你有很好的理由来避免类Baz[T，R@AndreyTyukin，“好的理由”我有很多这样的类，还有很多使用它们的代码，我想避免在任何地方都必须键入两个类型参数，其中一个是完全冗余的。我不确定
\uu$1
有什么问题，我更新了这个问题，希望现在我想在这里做的事情更清楚一些。我不记得细节了ls，但这似乎是一个有点相关的答案：。
trait Foo[T] { def doStuff(t: T) = ??? }
class Bar[P](val x: P) extends Foo[P] { type Foo = P }

def fooX[T](x: T, foo: Foo[T]) = foo.doStuff(x)

class Baz[R <: Bar[_]](bar: R){
  bar match {
    case b: Bar[p] => fooX[p](b.x, b)
  }
}

class Bar[P](val x: P) { type Foo = P ; val y: Foo = x }
class Baz[R <: Bar[_]](val bar: R) { val x: bar.Foo = bar.y }

trait Br { type Foo ; val x: Foo }
class Bar[F](val x: F) extends Br { type Foo = F }
class Baz[R <: Br](val bar: R) {val x: bar.Foo = bar.x }