使用具有参数化类型的特征的意外模式匹配行为

Question

我在 scala 2.12.9 中看到以下行为：

case class A()
case class B()

trait X {
  type T

  def handle: PartialFunction[Any, Unit] = {
    case in: T =>
      println(s"is a T, $in")
    case m =>
      print(s"not a T, $m")
  }

}

class X1 extends X {
  override type T = A
}


object Cast extends App {
  val x1 = new X1()
  x1.handle(B())
}

输出是是一个T,B()。我希望它“不是 T”，因为我已经将 X 的类型参数覆盖为 A。我错过了什么？

更新： 我不知道类型成员（不仅仅是类型参数）也会受到类型擦除的影响。谢谢你们！ @DmytroMitin 的解决方法非常有效。

Answer 1

这是因为类型擦除。

编译时出现警告

abstract type pattern X.this.T is unchecked since it is eliminated by erasure

尝试

import shapeless.TypeCase

trait X {
  type T

  val OfTypeT: TypeCase[T] // abstract val, not def

  def handle: PartialFunction[Any, Unit] = {
    case OfTypeT(in) =>
      println(s"is a T, $in")
    case m =>
      print(s"not a T, $m")
  }    
}

class X1 extends X {
  override type T = A
  override val OfTypeT = TypeCase[A]
}

val x1 = new X1()
x1.handle(B()) // not a T, B()

请参阅在 Scala 中模式匹配泛型类型的方法 https://gist.github.com/jkpl/5279ee05cca8cc1ec452fc26ace5b68b (another copy of a blog post: http://web.archive.org/web/20171013214913/http://www.cakesolutions.net/teamblogs/ways-to-pattern-match-generic-types-in-scala)

如果 T 是类型参数而不是类型成员，我们可以使用上下文绑定而不是覆盖

import shapeless.{TypeCase, Typeable}

abstract class X[T: Typeable] {
  private val OfTypeT = TypeCase[T]

  def handle: PartialFunction[Any, Unit] = {
    case OfTypeT(in) =>
      println(s"is a T, $in")
    case m =>
      print(s"not a T, $m")
  }
}

class X1 extends X[A]

val x1 = new X1()
x1.handle(B()) // not a T, B()

或者我们可以使用 TypeTag

import scala.reflect.runtime.universe.{TypeTag, typeOf, Type}

def getType[T: TypeTag](t: T): Type = typeOf[T]

abstract class X[T: TypeTag] {
  def handle: PartialFunction[Any, Unit] = {
    case in if typeOf[T] =:= getType(in) =>
      println(s"is a T, $in")
    case m =>
      print(s"not a T, $m")
  }
}

class X1 extends X[A]

val x1 = new X1()
x1.handle(B()) // not a T, B()

或ClassTag

import scala.reflect.ClassTag

abstract class X[T: ClassTag] {
  def handle: PartialFunction[Any, Unit] = {
    case in: T =>
      println(s"is a T, $in")
    case m =>
      print(s"not a T, $m")
  }
}

class X1 extends X[A]

val x1 = new X1()
x1.handle(B()) // not a T, B()

使用具有参数化类型的特征的意外模式匹配行为

Unexpected pattern matching behaviour using a trait with parameterized types

generics

scala

traits

pattern-matching

type-erasure