在 Scala 中进行模式匹配时，类型参数会限制编译器错误

Question

Why does the line

case Wrapper(rv: Ref[_]) => rv :: state

Not compile if

def f(r: Ref[_]): List[Ref[_]] = r :: state

compiles just fine?

Is there a way to get this code to compile while preserving as much type safety as possible ?

These lines are taken from the following self contained example:

object Test2 {

  trait Entity[T <: Entity[T]]


  case class Ref[T <: Entity[T]](t: T)

  type State[T <: Entity[T]] = List[Ref[T]]

  private var state: State[_] = ???

  trait SomeWrapper
  case class Wrapper[T <: Entity[T]](at: Ref[T]) extends SomeWrapper

  def matcher(w: SomeWrapper): Unit = w match {
    case Wrapper(rv: Ref[_]) => rv :: state // does not compile
    case _ => ???
  }

  def f(r: Ref[_]): List[Ref[_]] = r :: state // if this compiles fine, why the above does not compile ?


}

the code above gives the following compiler error:

Error:(40, 36) type arguments [Any] do not conform to class Ref's type parameter bounds [T <: Test2.Entity[T]]
    case Wrapper(rv: Ref[_]) => rv :: state // does not compile

Answer 1

Looks like a bug to me:

w match {
  case Wrapper(rv)         => (rv: Ref[_]) :: state // Compiles
  case Wrapper(rv: Ref[_]) => (rv: Ref[_]) :: state // Compiles
  case Wrapper(rv)         => rv           :: state // Doesn't Compile
  case Wrapper(rv: Ref[_]) => rv           :: state // Doesn't Compile???
  case e: Wrapper[_]       => e.at         :: state // Compiles
  case _ => ???
}