Scala - 返回与参数传递的相同类型

时间:2015-06-28 13:51:02

标签: scala generics code-reuse return-type generic-variance

假设我有一个类M,类A,B,C继承:

abstract M
A extends M
B extends M
C extends M

我想做这样的事情:

val a0:A = ...
val b0:B = ...
val c0:C = ...
val a1:A = transform[A](a0)
val b1:B = transform[B](b0)
val c1:C = transform[C](c0)

其中transform对每个子类型基本相同,只是结果对象的构造方式不同。

我有预感,这是不可能的,我需要复制代码并创建单独的转换方法或诉诸类型转换。或者有更好的方法吗?

修改

请注意,def transform[T<:M](t:T):T不起作用。如果我们尝试返回A,B或C,我们将收到以下错误消息。

  

A型的表达不符合预期的类型T

     

B型的表达不符合预期的类型T

     

C型的表达不符合预期的类型T

编辑2 也许有一些关于我正在尝试做的更详细的信息:

transform(m:M) = {
    val P = Property P computed from m
    m match {
        case a:A => construct and return new A from a with property P
        case b:B => construct and return new B from b with property P
        case c:C => construct and return new C from c with property P
        case _ => error
    }
}

如果我这样做,那么我需要演员阵容:

val a1:A = transform(a0).asInstanceOf[A]
val b1:B = transform(b0).asInstanceOf[B]
val c1:C = transform(c0).asInstanceOf[C]

我想消除它。

2 个答案:

答案 0 :(得分:3)

这很容易:

class M
class A extends M
class B extends M

def transform[T <: M](obj: T): T = {
    obj
}

val a0:A = new A
val a1:A = transform(a0)
val b0:B = new B
val b1:B = transform(b0)

答案 1 :(得分:2)

这取决于transform的实施。如果编译器清楚transform保留了该类型,那么@ Dimitry的答案就可以了。

如果您需要不太明显(对编译器)类型之间的关系,那么通常的方法是类型类模式。

trait Transformer[T] {
  def transform(t: T) : T
}

def transform[T: Transformer](t: T) = implicitly[Transformer[T]].transform(t)

implicit object ATransformer extends Transformer[A] {
  def transform(a: A): A = ...
}
implicit object BTransformer extends Transformer[B] {
  def transform(b: B): B = ...
}

然后,您可以在特定对象中实现A / B / C的特定转换,如果您有,编译器将只允许您调用transform隐式范围内适当的Transformer