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

我在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的答案解决方案非常有效。

这是因为类型擦除

在编译过程中有一个警告

抽象类型模式X.this.T被取消选中，因为它是通过擦除消除的

试一试

请参阅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()

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

或

ClassTag

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

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

---

这是因为类型擦除

在编译过程中有一个警告

抽象类型模式X.this.T被取消选中，因为它是通过擦除消除的

试一试

请参阅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()

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

或

ClassTag

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

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

---

我感到惊讶的是，

in:T

起作用了，这可能是因为在这一点上，

T

被视为一个Any，所以一切都会匹配。一般来说，这种设计感觉不安全。你到底想解决什么问题？什么是元问题？如果您愿意接受建议，我们可以尝试提供更安全的设计。类型成员和类型参数在运行时被删除，因此您无法检查某个内容是否是

t

的实例。我很惊讶

in:t

起作用，这可能是因为此时

t

被视为Any，因此所有内容都将匹配。一般来说，这种设计感觉不安全。你到底想解决什么问题？什么是元问题？如果您愿意接受建议，我们可以尝试提供更安全的设计。类型成员和类型参数在运行时被删除，因此您无法检查某个内容是否是

t

的实例。