39

正如在 SO 上多次讨论的那样，如果您没有详尽列出从密封类派生的所有类型，Scala 匹配会警告您。

我想要的是从特定父级派生的案例对象的编译时生成的 Iterable。或者，我会很高兴有一种方法可以让编译器告诉我在某些 Iterable 中没有所有必要的类型。我不想要运行时、基于反射的方法。

作为第二种方法的一个例子，我想让下面的粗略代码在指示的地方生成一个编译错误。

sealed trait Parent
case object A extends Parent
case object B extends Parent
case object C extends Parent

// I want a compiler error here because C is not included in the Seq()
val m = Seq(A, B).map(somethingUseful)

告诉我这是不可能的，请随时回答。似乎在某种程度上应该是可能的，因为当确定匹配不是详尽无遗时，编译器必须做基本相同的工作。

换一种方式考虑，我会采用类似于 Enumeration.values() 方法的方法，除了应用于案例对象。当然，我可以通过手动维护的值列表向父对象的伴随对象添加类似于上述代码的内容，但是当编译器可以为我执行此操作时，这似乎很容易出错。

// Manually maintained list of values
object Parent { 
    val values = Seq(A, B, C)
}
4

2 回答 2

26

更新。从 2.10.0-M7 开始，我们将此答案中提到的方法作为公共 API 的一部分公开。isSealed是ClassSymbol.isSealed和sealedDescendants是ClassSymbol.knownDirectSubclasses。

这不会是您问题的答案。

但是，如果您愿意满足于类似的东西Enumeration.values()，并且您正在使用最近的里程碑 2.10，并且您愿意处理一些丑陋的铸造到内部 API 业务，您可以编写以下内容：

import scala.reflect.runtime.universe._

def sealedDescendants[Root: TypeTag]: Option[Set[Symbol]] = {
  val symbol = typeOf[Root].typeSymbol
  val internal = symbol.asInstanceOf[scala.reflect.internal.Symbols#Symbol]
  if (internal.isSealed)
    Some(internal.sealedDescendants.map(_.asInstanceOf[Symbol]) - symbol)
  else None
}

现在，如果您有这样的层次结构：

object Test {
  sealed trait Parent
  case object A extends Parent
  case object B extends Parent
  case object C extends Parent
}

您可以获得密封类型层次结构成员的类型符号，如下所示：

scala> sealedDescendants[Test.Parent] getOrElse Set.empty
res1: Set[reflect.runtime.universe.Symbol] = Set(object A, object B, object C)

这很可怕，但我认为如果不编写编译器插件，你不会得到你真正想要的东西。

于 2012-08-22T20:39:57.987 回答
13

这是一个在 2.10.0-M6 上使用宏的工作示例：

（更新：为了让这个例子在 2.10.0-M7 中工作，你需要将 c.TypeTag 替换为 c.AbsTypeTag；为了让这个例子在 2.10.0-RC1 中工作，c.AbsTypeTag 需要替换为 c.WeakTypeTag )

import scala.reflect.makro.Context

object SealednessMacros {
  def exhaustive[P](ps: Seq[P]): Seq[P] = macro exhaustive_impl[P]

  def exhaustive_impl[P: c.TypeTag](c: Context)(ps: c.Expr[Seq[P]]) = {
    import c.universe._

    val symbol = typeOf[P].typeSymbol

    val seen = ps.tree match {
      case Apply(_, xs) => xs.map {
        case Select(_, name) => symbol.owner.typeSignature.member(name)
        case _ => throw new Exception("Can't check this expression!")
      }
      case _ => throw new Exception("Can't check this expression!")
    }

    val internal = symbol.asInstanceOf[scala.reflect.internal.Symbols#Symbol]    
    if (!internal.isSealed) throw new Exception("This isn't a sealed type.")

    val descendants = internal.sealedDescendants.map(_.asInstanceOf[Symbol])

    val objs = (descendants - symbol).map(
      s => s.owner.typeSignature.member(s.name.toTermName)
    )

    if (seen.toSet == objs) ps else throw new Exception("Not exhaustive!")
  }
}

这显然不是很健壮（例如，它假设您在层次结构中只有对象，并且它将失败A :: B :: C :: Nil），它仍然需要一些令人不快的转换，但它可以作为一个快速的概念验证。

首先我们在启用宏的情况下编译这个文件：

scalac -language:experimental.macros SealednessMacros.scala

现在，如果我们尝试编译这样的文件：

object MyADT {
  sealed trait Parent
  case object A extends Parent
  case object B extends Parent
  case object C extends Parent
}

object Test extends App {
  import MyADT._
  import SealednessMacros._

  exhaustive[Parent](Seq(A, B, C))
  exhaustive[Parent](Seq(C, A, B))
  exhaustive[Parent](Seq(A, B))
}

我们会Seq在缺少的情况下得到一个编译时错误C：

Test.scala:14: error: exception during macro expansion: 
java.lang.Exception: Not exhaustive!
        at SealednessMacros$.exhaustive_impl(SealednessMacros.scala:29)

  exhaustive[Parent](Seq(A, B))
                    ^
one error found

请注意，我们需要使用指示父级的显式类型参数来帮助编译器。

于 2012-08-27T01:07:08.987 回答