我有一个Any
数组(在现实生活中,它是一个Spark Row
,但它足以隔离问题)
object Row {
val buffer : Array[Any] = Array(42, 21, true)
}
我想对其元素应用一些操作。因此,我定义了一个简单的 ADT 来定义类型A
上的compute
操作
trait Op[A] {
def cast(a: Any) : A = a.asInstanceOf[A]
def compute(a: A) : A
}
case object Count extends Op[Int] {
override def compute(a: Int): Int = a + 1
}
case object Exist extends Op[Boolean] {
override def compute(a: Boolean): Boolean = a
}
鉴于我有一个所有操作的列表,并且我知道哪个操作要应用于每个元素,让我们使用这些操作。
object GenericsOp {
import Row._
val ops = Seq(Count, Exist)
def compute() = {
buffer(0) = ops(0).compute(ops(0).cast(buffer(0)))
buffer(1) = ops(0).compute(ops(0).cast(buffer(1)))
buffer(2) = ops(1).compute(ops(1).cast(buffer(2)))
}
}
根据设计,对于给定的操作,类型在 cast
和 combine
之间对齐。但不幸的是,以下代码无法编译。错误是
Type mismatch, expected: _$1, actual: AnyVal
有没有办法让它工作?
我通过使用抽象类型成员而不是类型参数找到了解决方法。
object AbstractOp extends App {
import Row._
trait Op {
type A
def compute(a: A) : A
}
case object Count extends Op {
type A = Int
override def compute(a: Int): Int = a + 1
}
case object Exist extends Op {
type A = Boolean
override def compute(a: Boolean): Boolean = a
}
val ops = Seq(Count, Exist)
def compute() = {
val op0 = ops(0)
val op1 = ops(1)
buffer(0) = ops(0).compute(buffer(0).asInstanceOf[op0.A])
buffer(1) = ops(0).compute(buffer(1).asInstanceOf[op0.A])
buffer(2) = ops(1).compute(buffer(2).asInstanceOf[op1.A])
}
}
有没有更好的方法?
似乎可以通过Op[A]
扩展Any => A
来简化您的代码:
trait Op[A] extends (Any => A) {
def cast(a: Any) : A = a.asInstanceOf[A]
def compute(a: A) : A
def apply(a: Any): A = compute(cast(a))
}
case object Count extends Op[Int] {
override def compute(a: Int): Int = a + 1
}
case object Exist extends Op[Boolean] {
override def compute(a: Boolean): Boolean = a
}
object AbstractOp {
val buffer: Array[Any] = Array(42, 21, true)
val ops: Array[Op[_]] = Array(Count, Count, Exist)
def main(args: Array[String]): Unit = {
for (i <- 0 until buffer.size) {
buffer(i) = ops(i)(buffer(i))
}
println(buffer.mkString("[", ",", "]"))
}
}
由于它无论如何都asInstanceOf
任何地方,因此它不会使代码比以前更不安全。
更新
如果无法更改Op
接口,则调用cast
和compute
会更麻烦一些,但仍然可以:
trait Op[A] {
def cast(a: Any) : A = a.asInstanceOf[A]
def compute(a: A) : A
}
case object Count extends Op[Int] {
override def compute(a: Int): Int = a + 1
}
case object Exist extends Op[Boolean] {
override def compute(a: Boolean): Boolean = a
}
object AbstractOp {
val buffer: Array[Any] = Array(42, 21, true)
val ops: Array[Op[_]] = Array(Count, Count, Exist)
def main(args: Array[String]): Unit = {
for (i <- 0 until buffer.size) {
buffer(i) = ops(i) match {
case op: Op[t] => op.compute(op.cast(buffer(i)))
}
}
println(buffer.mkString("[", ",", "]"))
}
}
请注意模式中带有类型参数的ops(i) match { case op: Opt[t] => ... }
部分:这使我们能够确保cast
返回compute
接受的t
。
作为比 Andrey Tyukin 更通用的解决方案,您可以在 Op
之外定义该方法,因此即使无法修改Op
也可以工作:
def apply[A](op: Op[A], x: Any) = op.compute(op.cast(x))
buffer(0) = apply(ops(0), buffer(0))