Question

我在Scala特性和类型擦除方面遇到了麻烦。我有这个特点：

trait Meta[T] {
  def ~=(e: T): Boolean
}

现在我想使用模式匹配来检查这种情况：

(m,i) match {
case (x:Meta[T], y: T) if x ~= y => println ("right")
case _ => println ("wrong")}

来自T的{{1}}应该是x: Meta[T]的类型，或y应该是y的子类型。如果类型不匹配，我会得到T。但是如果类型不正确，则不应执行ClassCastException。有没有这个或者我必须抓住异常并以这种方式处理它？</ p>

我做了一个尽可能短的运行示例：

x ~= y

Answer 1

更新：最后添加替代方案。

由于类型擦除，您遇到泛型类型时模式匹配的限制。

然而，一切都没有丢失。我们可以依靠ClassManifest来实现一个通用的方法来将你的类转换为目标类型T（和另一个类似的转换为Meta [T]）：

trait Meta[T] { this: T =>
  type t = T
  def metaManifest: ClassManifest[T]
  def ~=(e: T): Boolean
}

abstract sealed class Base {
  def as[T:ClassManifest]: Option[T] = {
    if ( classManifest[T].erasure.isAssignableFrom( this.getClass ) ) Some( this.asInstanceOf[T] )
    else None
  }
  def asMeta[T:ClassManifest]: Option[T with Meta[T]] = {
    this match {
      case meta: Meta[_] if classManifest[T] <:< meta.metaManifest => as[T].asInstanceOf[Option[T with Meta[T]]]
      case _ => None
    }
  }
}
abstract sealed class A extends Base
case class Ide(s: String) extends A
case class MIde(s: String) extends A with Meta[A] {
  val metaManifest = classManifest[A]
  def ~=(e: A) = e match {
    case e: Ide => true
    case e: MIde => false
  }
}
sealed abstract class B extends Base
case class Foo(s: String) extends B

让我们在REPL中测试一下：

scala> m.as[A]
res17: Option[A] = Some(MIde(x))
scala> m.asMeta[A]
res18: Option[A with Meta[A]] = Some(MIde(x))
scala> i.as[A]
res19: Option[A] = Some(Ide(i))
scala> i.asMeta[A]
res20: Option[A with Meta[A]] = None
scala> f.as[A]
res21: Option[A] = None
scala> f.asMeta[A]
res22: Option[A with Meta[A]] = None

听起来不错。现在我们可以从这里重写模式匹配：

(m, i) match {
  case (x: Meta[T], y: T) if x ~= y => println("right")
  case _ => println("wrong")
}

到此：

(m.asMeta[T], i.as[T]) match {
  case (Some(x), Some(y)) if x ~= y => println("right")
  case _ => println("wrong")
}

所以你的例子现在看起来像这样：

object Test {

  val m = MIde("x")
  val i = Ide("i")
  val f = Foo("f")

  def test[T:ClassManifest]() {
    (m.asMeta[T], i.as[T]) match {
      case (Some(x), Some(y)) if x ~= y => println("right")
      case _ => println("wrong")
    }
    // -> right
    (m.asMeta[T], f.as[T]) match {
      case (Some(x), Some(y)) if x ~= y => println("right")
      case _ => println("wrong")
    }
  }
}

更新：如果每次混合metaManifest时都设置为显式Meta，则可以让scala通过在Meta构造函数中隐含地传递它来自动推断它。这意味着Meta现在必须是一个类，因此A和B（以及必须显示为Meta类型参数的所有类似类型）现在必须是特质，因为你不能混合2个班级。所以你基本上交换另一个限制。选择你最喜欢的一个。我们走了：

abstract sealed class Meta[T]( implicit val metaManifest: ClassManifest[T] ) { this: T =>
  type t = T
  def ~=(e: T): Boolean
}

trait Base {
  def as[T:ClassManifest]: Option[T] = {
    if ( classManifest[T].erasure.isAssignableFrom( this.getClass ) ) Some( this.asInstanceOf[T] )
    else None
  }
  def asMeta[T:ClassManifest]: Option[T with Meta[T]] = {
    this match {
      case meta: Meta[_] if classManifest[T] != ClassManifest.Nothing && classManifest[T] <:< meta.metaManifest => as[T].asInstanceOf[Option[T with Meta[T]]]
      case _ => None
    }
  }
}

trait A extends Base
case class Ide(s: String) extends A
case class MIde(s: String) extends Meta[A] with A {
  def ~=(e: A) = e match {
    case e: Ide => true
    case e: MIde => false
  }
}
trait B extends Base
case class Foo(s: String) extends B

object Test {
  val m = MIde("x")
  val i = Ide("i")
  val f = Foo("f")

  def test[T:ClassManifest]() {
    (m.asMeta[T], i.as[T]) match {
      case (Some(x), Some(y)) if x ~= y => println("right")
      case _ => println("wrong")
    }
    (m.asMeta[T], f.as[T]) match {
      case (Some(x), Some(y)) if x ~= y => println("right")
      case _ => println("wrong")
    }
  }
}

最后，如果两种解决方案都不适合您，您可以尝试另一种解决方案：不要将Meta[T]与T混合，而是将其包裹起来。 Meta[T]只会成为T的包装，您甚至可以添加从Meta[T]到其包装值的隐式转换，以便可以有效地使用Meta[T]的实例像T的实例几乎是透明的。

如何将模式匹配与参数化特征结合使用？

1 个答案: