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

13 浏览
0 Comments

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

我在编译以下示例代码时遇到了错误。

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)
  }
}

是否有更好的方法或一些技巧？

0

2 答案

0 Comments

使用相同类型参数作为参数类型和参数类型的匹配表达式的原因是希望在子类中自定义匹配表达式。然而，这种做法是错误的，因为在Scala中，类型参数不能用作匹配表达式的参数类型。

为了解决这个问题，我建议使用类型类（typeclass）来替代。类型类是一种可以为不同类型提供相同行为的抽象机制。通过使用类型类，我们可以为每个子类定义一个实例，并在函数中使用相应的实例来执行所需的操作。

下面是使用类型类来重写原始代码的示例：

sealed trait Base
object Base {
  final case class A() extends Base
  final case class B() extends Base
  trait Builder[T <: Base] {
    def build(): T
  }
  object Builder {
    implicit val ABuilder: Builder[A] = new Builder[A] {
      override def build(): A = A()
    }
    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()
  val a: Base.A = func[Base.A] // res: Base.A = A()
  val b: Base.B = func[Base.B] // res: Base.B = B()
}

在上述代码中，我们定义了一个类型类`Builder`，它有一个`build`方法用于构建相应的子类实例。然后，我们为每个子类`A`和`B`分别提供了一个实例。在`func`函数中，我们使用类型参数`T`和隐式参数`builder`来获取相应的构建器实例，并调用`build`方法来构建子类实例。

通过使用类型类，我们可以避免使用相同类型参数作为参数类型和参数类型的匹配表达式的问题，并且可以更加灵活地定义和使用不同子类的自定义行为。

需要注意的是，上述代码是在Scala 2中编写的。在Scala 3（也称为Dotty）中，宏（macros）的引入将允许我们在原始代码中编写类似的逻辑，而无需使用类型类。

0
0 Comments

问题的出现原因是，在匹配表达式中，使用与参数类型和参数类型相同的类型参数会导致类型不匹配。为了解决这个问题，可以在匹配的最后一行使用asInstanceOf[T]将返回值转换为指定的类型参数。

但是，如果有很多匹配情况需要处理，这种方式会很麻烦，需要在每个分支后面都加上asInstanceOf[T]。

为了解决这个问题，可以将asInstanceOf[T]放在匹配的最后一行，而不是每个分支都加上。这样可以避免重复的代码。

另外，需要注意的是，这种设计本质上是不安全的，因为Base的子类型除了Base、A和B之外还有其他类型，比如单例类型（a.type）、复合类型（A with SomeTrait）、Null等等，都可以用作类型参数T。可能更好的做法是使用重载来处理不同的参数类型。

在这种方案中，定义了一个Transform类，其中func方法接受Base类型的参数，并根据参数的实际类型调用相应的func方法。这样可以避免类型不匹配的问题。

另外，还定义了一个ExtTransform类，它继承自Transform类，并重写了func方法。这样可以根据需要对func方法进行特定的处理。

不过，这种方案也没有考虑到A with SomeTrait类型的值会匹配到A类型的问题。这显然是一个问题，需要进一步考虑解决方案。

0