如何用案例类定义提取器？

Question

我想使用 List 定义的 case class match Seq[Byte]，但是发生了编译器错误。

带有编译器错误的用例类

case class :: (head: Byte, tail: Seq[Byte])        
def doMatchWithCaseClass(queue: Seq[Byte]) = {    
  queue match {
    case h :: t => println("Good!") //can't compile
    case _ => println("God!>_<")
  }
}
doMatchWithCaseClass(Seq(1,2,3))

编译器错误：

Error:(93, 14) constructor cannot be instantiated to expected type;
 found   : ::
 required: Seq[Byte]
      case h :: t => println("Good!") //can't compile
             ^

使用@isaias-b 邮政编码更新

  final case class :::: (override val head: Int, override val tail: Seq[Int]) extends Seq[Int] {
    override def length: Int = tail.length + 1
    override def iterator: Iterator[Int] = (head :: tail.toList).toIterator
    override def apply(idx: Int) = {
      1.toByte // just for simple
    }
  }

匹配码：

  def doMatchWithCaseClass(queue: Seq[Int]) = {
    queue match {
      case h :::: t => println("case class - Good! ^_^")
      case x =>
        println(s"case class - God >_<! $x")
    }
  }

测试代码：

  doMatchWithCaseClass(Seq(1,2,3))

控制台结果：

> case class - God >_<! List(1, 2, 3)

上面的代码没有任何编译错误，但这不是我的预期结果。
希望有人能指出错误。谢谢

Answer 1

我不能 100% 确定这是否是所需的解决方案，但这似乎可行：

case class ::(override val head:Int, override val tail: Seq[Int]) 
  extends Seq[Int] { 
    def iterator = ??? 
    def apply(idx: Int): Int = ???
    def length: Int = ??? 
}

正如编译器错误告诉您的那样，它找到了 :: 类型的实例，但需要 Seq[Byte]。我提供了一个带有Int 的示例，它现在扩展了Seq[Int]，这让我可以更进一步。

scala> case class ::(head:Int, tail: Seq[Int]) extends Seq[Int]
<console>:10: error: overriding method head in trait IterableLike of type => Int;
 value head needs `override' modifier
       case class ::(head:Int, tail: Seq[Int]) extends Seq[Int]
                     ^

所以我添加了override 关键字，在另一个错误之后，我也添加了val 关键字。然后还有 3 个给定的抽象方法需要定义，我提供了在控制台上打印的存根。这样就可以执行以下操作：

scala> Seq(1,2,3) match { case ::(a, as) => "list"; case _ => "empty!" }
res5: String = empty!

希望在为 3 种必需方法提供正确实现时，这种情况会消失。但是，编译器不再抱怨了……

更新 1

@badcook 指出...

您的 :::: 案例类不起作用，因为子类型可以说是“错误的方式”；虽然您的 :::: 是 Seq，但队列不是 :::: 并且后者在模式匹配中很重要。

他是对的，当通常试图支持组合而不是继承时，扩展总是感觉很奇怪。现在是here is a comparison from Martin Odersky's online book about scala，它指出了使用case classes 实现的提取器与使用单独的un/apply 和un/applySeq 方法之间的区别。

尽管它们非常有用，但案例类有一个缺点：它们暴露了数据的具体表示。

用他的话说，将提取器与表示分离，利用表示独立性。这就引出了一个问题：这是因为技术限制的硬选择，还是软选择？大多数时候，这不是一个艰难的选择：

那么对于模式匹配，您应该更喜欢这两种方法中的哪一种？这取决于。如果您为封闭的应用程序编写代码，案例类通常更可取，因为它们在简洁、速度和静态检查方面具有优势。如果您决定稍后更改类层次结构，则需要重构应用程序，但这通常不是问题。另一方面，如果您需要向未知客户端公开类型，则提取器可能更可取，因为它们保持表示独立性。

幸运的是，您无需立即做出决定。您总是可以从案例类开始，然后，如果需要，可以更改为提取器。因为提取器上的模式和案例类上的模式在 Scala 中看起来完全一样，所以客户端中的模式匹配将继续有效。

但是，现在有一部分描述了该指南存在例外情况！

本章讨论的电子邮件地址就是这样一个例子。在这种情况下，提取器是唯一可能的选择。

更新 2

我也不是 100% 确定，如果这也适用于当前场景，如果您面临遇到此限制的情况。 @badcook 似乎知道这一点，因为他指出的另一件事是：

根据您对其他回复的 cmets，您似乎已经了解提取器对象，并且实际上只是想看看 case 类是否可以节省您为预先存在的类型键入自己的 unapply 和 unapplySeq 方法的工作。

很遗憾，答案是否定的。你必须使用 unapply 和/或 unapplySeq （它们还不错:)）。

我们后来澄清了这一点，所以我现在想自己也理解它。我将通过背诵自己来总结谈话的摘录。为此假设有以下case class Y(x: X)：

case class Y 中提供的 def unapply(y:Y):X 方法强烈绑定到它的输入和输出类型。将其他内容放入其中的唯一方法是使用继承。那就麻烦了。

在我目前的理解中，这个问题被称为表示依赖。

Answer 2

您可以使用稍微不同的提取器直接匹配Seq。

def doMatch(queue: Seq[Byte]) = {
  queue match {
    case h +: t => println(s"Head: $h and tail: $t")
    // You could also do case Nil =>...
    case t      => println(s"Bad: $t")
  }
}

doMatch(List(1, 2, 3)) // Head: 1 and tail: List(2, 3)
doMatch(List())        // Bad: List()

编辑：

看来您不只是想在Seqs 上进行匹配，而是在考虑更通用的模式匹配。

根据您对其他回复的 cmets，您似乎已经了解提取器对象，并且真的只是想看看 case class 是否可以节省您输入自己的 unapply 和 unapplySeq 方法的工作量预先存在的类型。

很遗憾，答案是否定的。你必须使用unapply 和/或unapplySeq（它们还不错:)）。

您的:::: 案例类不起作用，因为子类型可以说是“错误的方式”；虽然您的:::: 是Seq，但queue 不是::::，后者在模式匹配中很重要。

模式匹配器看到您的第一个case，并尝试寻找相关的unapply 方法。不幸的是，:::: 生成的unapply 方法有签名:::: => Option[(Int, Seq[Int])]，而queue 不是:::: 所以匹配失败。

另一方面

object JustWriteUnapplyAndLifeWillBeGood {
  def unapply(xs: Seq[Int]): Option[(Int, Seq[Int])] =
    if (xs.isEmpty) None else Some(xs.head, xs.tail)
}

工作得很好。

Seq(1, 2, 3) match {
  case JustWriteUnapplyAndLifeWillBeGood(head, tail) => 
    println(s"head: $head, tail: $tail")
} // head: 1, tail: List(2, 3)

// Look Ma, no prefix!
Seq(1, 2, 3) match {
  case head JustWriteUnapplyAndLifeWillBeGood tail =>
    println(s"head: $head, tail: $tail")
} // head: 1, tail: List(2, 3)

或override 生成的unapply 方法:::: 具有正确的签名。