使用与参数类型相同的类型参数和具有匹配表达式的参数类型

Question

编译以下示例代码时出现错误。

abstract class Base
case class A(i: Int)    extends Base
case class B(s: String) extends Base

class Transform {
  def func[T <: Base](arg: T): T = arg match {
    case A(i) => A(i)
    case B(s) => B(s)
  }
}

错误是

Example.scala:9: error: type mismatch;
 found   : A
 required: T
    case A(i) => A(i)
                  ^
Example.scala:10: error: type mismatch;
 found   : B
 required: T
    case B(s) => B(s)
                  ^
two errors found

这些错误是合理的。
为了避免这种情况，我需要将asInstanceOf[T] 放在像A(i).asInstanceOf[T] 这样的实例化后面。但是，如果有很多匹配案例模式，那么对所有返回值都这样做很烦人。

另外，我想使用Transform类作为父类并覆盖func()来执行如下代码的具体操作。

class ExtTransform extends Transform {
  override def func[T <: Base](arg: T): T = arg match {
    case A(i) => A(i + 1)
    case _    => super.func(arg)
  }
}

有没有更好的方法或技巧？

Answer 1

为了避免这种情况，我需要将 asInstanceOf[T] 放在像 A(i).asInstanceOf[T] 这样的实例化之后。但是，如果有很多匹配案例模式，那么对所有返回值都这样做很烦人。

嗯，这个问题很简单：把它放在比赛结束时的一个地方，而不是每个分支。

override def func[T <: Base](arg: T): T = (arg match {
  case A(i) => A(i)
  case B(s) => B(s)
}).asInstanceOf[T]

但请注意，您的设计本质上是不安全的，因为除了 Base、A 和 B 之外还有 Base 的子类型：单例类型 (a.type)、复合类型 (A with SomeTrait)、 Null...，其中任何一个都可以用作T。重载可能会更好：

class Transform {
  def func(arg: Base): Base = arg match {
    case arg: A => func(arg)
    case arg: B => func(arg)
  }

  def func(arg: A): A = arg
  def func(arg: B): B = arg
}

class ExtTransform extends Transform {
  override def func(arg: A): A = A(arg.i + 1)
}

Answer 2

我建议改用 typeclass。

sealed trait Base

object Base {
  final case class A() extends Base
  final case class B() extends Base

  sealed trait Builder[T <: Base] {
     def build(): T
  }

  object Builder {
     final implicit val ABuilder: Builder[A] = new Builder[A] {
       override def build(): A = A()
     }

     final implicit val BBuilder: Builder[B] = new Builder[B] {
       override def build(): B = B()
     }
  }
}

object Main extends App {
  def func[T <: Base](implicit builder: Base.Builder[T]): T =
    builder.build()

  func[Base.A] // res: Base.A = A()
  func[Base.B] // res: Base.B = B()
}