Scala类型擦除对于模式匹配的影响

Question

我一直在论坛和Google上寻找关于Scala类型擦除问题的答案。然而，我找不到任何解答我的问题的内容。

我正在努力应对ParamClass类型参数对象的模式匹配问题。我需要在bar方法中根据传入对象的类型进行模式匹配。我看到了一些解决方案，例如：

bar[X](a : X)(implicit m : Manifest[X])

这个方法可以解决我的问题，但是我不能使用它，因为bar方法已经被重写了。(实际上在Akka演员框架中是receive partial函数)。以下是代码，应该很容易理解：

class ParamClass[A : Manifest] {
  def bar(x : Any) = x match {
    case a: A => println("Found A: " + a)
    case _ =>    println("No match: " + x)
  }
}

object ErasureIssue {
  def main(args: Array[String]) {
    val clz = new ParamClass[Int]
    clz.bar("faf")
    clz.bar(2.3)
    clz.bar(12)   // this should match, but does not
  }
}

ErasureIssue.main(null)

非常感谢您提供的帮助。顺便提一句，我使用的是Scala 2.9.1。

-J

- pedesky

Answer 1

理论上，您可以像这样检查 bar ：x.getClass == implicitly [Manifest [A]] .erasure ，但对于诸如 Int 之类的原始类型，它会失败，因为清单正确擦除为 Int ，但却用封装类型 java.lang.Integer 调用了 bar ... :-(

您可以要求 A 是一个 AnyRef ，以便获得封装的清单：

class ParamClass[A <: AnyRef : Manifest] {
  def bar(x : Any) = x match {
    case _ if x.getClass == implicitly[Manifest[A]].erasure =>
      println("Found A: " + x.asInstanceOf[A])
    case _ => println("No match: " + x)
  }
}

object ErasureIssue {
  def main(args: Array[String]) {
    val clz = new ParamClass[Integer] // not pretty...
    clz.bar("faf")
    clz.bar(2.3)
    clz.bar(12)   // ok
  }
}

ErasureIssue.main(null)

考虑到您需要构建基本数组，您可以直接存储装箱类，而不受未装箱的清单的影响。

object ParamClass {
  def apply[A](implicit mf: Manifest[A]) = {
    val clazz = mf match {
      case Manifest.Int => classOf[java.lang.Integer] // boxed!
      case Manifest.Boolean => classOf[java.lang.Boolean]
      case _ => mf.erasure
    }
    new ParamClass[A](clazz)
  }
}
class ParamClass[A] private[ParamClass](clazz: Class[_])(implicit mf: Manifest[A]) {
  def bar(x : Any) = x match {
    case _ if x.getClass == clazz =>
      println("Found A: " + x.asInstanceOf[A])
    case _ => println("No match: " + x)
  }

  def newArray(size: Int) = new Array[A](size)

  override def toString = "ParamClass[" + mf + "]"
}

val pi = ParamClass[Int]
pi.bar("faf")
pi.bar(12)
pi.newArray(4)

val ps = ParamClass[String]
ps.bar("faf")
ps.bar(12)
ps.newArray(4)

- 0__

---

感谢您的回答（我会点赞的，但我的声望还不够高）。我不知道在A的清单上进行“隐式”操作。然而，在我的某个问题中，由于性能原因，类型参数仅为基本类型。那么在这种情况下我该怎么办？ - pedesky

请注意，使用 def bar(x: Any) 将必然导致装箱，因此除非您有许多其他使用类型 A 的方法并且在 ParamClass 定义上使用 @specialized，否则您不会对原始类型获得任何性能优势。 - 0__

A参数在内部用于创建Array[A]，大多数代码都在其上运行（例如，在内部期望int[]）。在这种情况下，bar方法只是偶尔使用。然而，在创建ParamClass时，我没有使用@specialized注释，因此在使用@specialized之前，可能会白费力气？ - pedesky

Answer 2

如果你尝试使用-unchecked编译，你将立即收到警告。

test.scala:3: 警告：类型模式中的抽象类型A未经检查，因为它被擦除而消失。case a: A => println("Found A: " + a)

如果现在想深入了解，可以使用scalac -print

[[syntax trees at end of cleanup]]// Scala source: test.scala
package <empty> {
  class ParamClass extends java.lang.Object with ScalaObject {
    def bar(x: java.lang.Object): Unit = {
      <synthetic> val temp1: java.lang.Object = x;
      if (temp1.$isInstanceOf[java.lang.Object]())
        {
          scala.this.Predef.println("Found A: ".+(temp1))
        }
      else
        {
          scala.this.Predef.println("No match: ".+(x))
        }
    };
    def this(implicit evidence$1: scala.reflect.Manifest): ParamClass = {
      ParamClass.super.this();
      ()
    }
  };
  final object ErasureIssue extends java.lang.Object with ScalaObject {
    def main(args: Array[java.lang.String]): Unit = {
      val clz: ParamClass = new ParamClass(reflect.this.Manifest.Int());
      clz.bar("faf");
      clz.bar(scala.Double.box(2.3));
      clz.bar(scala.Int.box(12))
    };
    def this(): object ErasureIssue = {
      ErasureIssue.super.this();
      ()
    }
  }
}

现在看到这段代码，你会发现A已经变成了java.lang.Object，这导致所有参数都与条款匹配。

- Edmondo