[英]Scala, pattern matching on a tuple of generic trait, checking if types are equal
我知道很多有关泛型类型的类型擦除和模式匹配的问题,但是我无法从答案中了解我该怎么办,并且我无法在标题中更好地解释它。
以下代码段已简化以展示我的情况。
所以我有个特质
trait Feature[T] {
value T
def sub(other: Feature[T]): Double
}
// implicits for int,float,double etc to Feature with sub mapped to - function
...
那我上课
class Data(val features: IndexedSeq[Feature[_]]) {
def sub(other: Data): IndexedSeq[Double] = {
features.zip(other.features).map {
case(e1: Feature[t], e2: Feature[y]) => e1 sub e2.asInstanceOf[Feature[t]]
}
}
}
我有一个这样的测试用例
case class TestFeature(val value: String) extends Feature[String] {
def sub(other: Feature[String]): Double = value.length - other.length
}
val testData1 = new Data(IndexedSeq(8, 8.3f, 8.232d, TestFeature("abcd"))
val testData2 = new Data(IndexedSeq(10, 10.1f, 10.123d, TestFeature("efg"))
testData1.sub(testData2).zipWithIndex.foreach {
case (res, 0) => res should be (8 - 10)
case (res, 1) => res should be (8.3f - 10.1f)
case (res, 2) => res should be (8.232d - 10.123d)
case (res, 3) => res should be (1)
}
这以某种方式起作用。 如果我尝试对具有相同features
索引中不同类型的Data
实例进行子操作, ClassCastException
得到ClassCastException
。 这实际上满足了我的要求,但是如果可能的话,我想使用Option
而不是抛出异常。 如何使以下代码起作用?
class Data(val features: IndexedSeq[Feature[_]]) {
def sub(other: Data): IndexedSeq[Double] = {
features.zip(other.features).map {
// of course this does not work, just to give idea
case(e1: Feature[t], e2: Feature[y]) if t == y => e1 sub e2.asInstanceOf[Feature[t]]
}
}
}
另外,我对Scala真的没有经验,所以我想获得有关这种结构的反馈。 还有其他方法可以做到吗?哪种方法最有意义?
泛型在运行时不存在, IndexedSeq[Feature[_]]
甚至在编译时就忘记了类型参数是什么(@Jatin的回答将不允许您使用Feature[_]
的混合类型列表构造Data
Feature[_]
)。 最简单的答案可能是刚刚捕获异常(使用catching
和opt
从scala.util.control.Exception
)。 但是,要回答书面问题:
您可以在运行时检查类:
case (e1: Feature[t], e2: Feature[y]) if e1.value.getClass ==
e2.value.getClass => ...
或在Feature
包括类型信息:
trait Feature[T] {
val value: T
val valueType: ClassTag[T] // write classOf[T] in subclasses
def maybeSub(other: Feature[_]) = other.value match {
case valueType(v) => Some(actual subtraction)
case _ => None
}
}
更为复杂的“适当”解决方案可能是使用Shapeless HList
将类型信息保留在列表中:
// note the type includes the type of all the elements
val l1: Feature[Int] :: Feature[String] :: HNil = f1 :: f2 :: HNil
val l2 = ...
// a 2-argument function that's defined for particular types
// this can be applied to `Feature[T], Feature[T]` for any `T`
object subtract extends Poly2 {
implicit def caseFeatureT[T] =
at[Feature[T], Feature[T]]{_ sub _}
}
// apply our function to the given HLists, getting a HList
// you would probably inline this
// could follow up with .toList[Double]
// since the resulting HList is going to be only Doubles
def subAll[L1 <: HList, L2 <: HList](l1: L1, l2: L2)(
implicit zw: ZipWith[L1, L2, subtract.type]) =
l1.zipWith(l2)(subtract)
这样,只能为所有元素匹配的l1
和l2
调用subAll
, 这是在编译时强制执行的 。 (如果您确实想执行Option
您可以在subtract
有两个at
,一个用于相同类型的Feature[T]
,一个用于不同类型的Feature[_]
,但是将其完全排除似乎是一个更好的选择解)
您可以执行以下操作:
class Data[T: TypeTag](val features: IndexedSeq[Feature[T]]) {
val t = implicitly[TypeTag[T]]
def sub[E: TypeTag](other: Data[E]): IndexedSeq[Double] = {
val e = implicitly[TypeTag[E]]
features.zip(other.features).flatMap{
case(e1, e2: Feature[y]) if e.tpe == t.tpe => Some(e1 sub e2.asInstanceOf[Feature[T]])
case _ => None
}
}
}
接着:
case class IntFeature(val value: Int) extends Feature[Int] {
def sub(other: Feature[Int]): Double = value - other.value
}
val testData3 = new Data(IndexedSeq(TestFeature("abcd")))
val testData4 = new Data(IndexedSeq(IntFeature(1)))
println(testData3.sub(testData4).zipWithIndex)
给出Vector()
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.