除列表之外的序列上的 Scala 模式匹配

Question

我有以下代码，它对现在列表中的每个元素进行递归操作

def doMatch(list: List[Int]): Unit = list match {
  case last :: Nil  => println("Final element.")
  case head :: tail => println("Recursing..."); doMatch(tail)
}

，忽略可以通过 filter() 和 foreach() 使用此功能，这工作得很好。但是，如果我尝试更改它以接受任何 Seq[Int]，我会遇到问题：

• Seq 没有​​ ::，但它确实有 +:，据我所知，这基本上是同样的事情。但是，如果我尝试在 head +: tail 上匹配，编译器会抱怨“错误：未找到：值+：”
• Nil 特定于 List，并且我不确定用什么替换它。如果我解决了上一个问题，我将尝试 Seq()

这是我认为代码应该看起来的样子，除了它不起作用：

def doMatch(seq: Seq[Int]): Unit = seq match {
  case last +: Seq() => println("Final element.")
  case head +: tail  => println("Recursing..."); doMatch(tail)
}

编辑：这么多好的答案！我接受agilesteel的答案，因为他是第一个指出 :: 在我的示例中不是运算符，而是案例类，因此存在差异的答案。

Answer 1

截至 2012 年 3 月的 IDE，这在 2.10+ 中有效：

  def doMatch(seq: Seq[Int]): Unit = seq match {
    case last +: Seq() => println("Final element.")
    case head +: tail  => println("Recursing..."); doMatch(tail)
  }                                               //> doMatch: (seq: Seq[Int])Unit

  doMatch(List(1, 2))                             //> Recursing...
                                                  //| Final element.

更一般地，为 Seq 添加了两个不同的 head/tail 和 init/last 分解对象，镜像附加/前置href="https://github.com/scala/scala/commit/b3efb3d493605d1c7e106e5f0a697b52ebb3d97c">SeqExtractors：

List(1, 2) match { case init :+ last => last } //> res0: Int = 2                                              
List(1, 2) match { case head +: tail => tail } //> res1: List[Int] = List(2)                                               
Vector(1, 2) match { case init :+ last => last } //> res2: Int = 2                                              
Vector(1, 2) match { case head +: tail => tail } //> res3: scala.collection.immutable.Vector[Int] = Vector(2)

Answer 2

有点作弊，但事情是这样的：

def doMatch(seq: Seq[Int]): Unit = seq match {
  case Seq(x) => println("Final element " + x)
  case Seq(x, xs@_*) => println("Recursing..." + x); doMatch(xs)
}

不要问我为什么 xs* 不起作用......

Answer 3

Scala 中有两个 :: （发音为 cons）。一种是在class List中定义的运算符，另一种是class（List的子类），表示一个具有头和尾特征的非空列表。

head :: tail 是一个构造函数模式，它在语法上是从 ::(head, tail) 修改而来的。

:: 是一个案例类，这意味着为其定义了一个提取器对象。

Answer 4

您实际上可以为 +: 定义一个对象来完全执行您正在寻找的操作：

object +: { 
  def unapply[T](s: Seq[T]) = 
    if(s.nonEmpty)
      Some(s.head, s.tail) 
    else
      None
}

scala> val h +: t = Seq(1,2,3)
h: Int = 1
t: Seq[Int] = List(2, 3)

然后您的代码将完全按照预期工作。

这是有效的，因为当用于模式匹配时，h +: t 相当于 +:(h,t)。

Answer 5

我认为标准库中不存在对任意序列的模式匹配支持。不过，您可以在没有模式匹配的情况下完成此操作：

  def doMatch(seq: Seq[Int]) {
    if (seq.size == 1) println("final element " + seq(0)) else {
      println("recursing")
      doMatch(seq.tail)
    }
  }
  doMatch(1 to 10)

不过，您可以定义自己的提取器对象。请参阅http://www.scala-lang.org/node/112

object SEQ {
  def unapply[A](s:Seq[A]):Option[(A, Seq[A])] = {
    if (s.size == 0) None else {
      Some((s.head, s.tail))
    }
  }
}

def doMatch(seq: Seq[Int]) {
  seq match {
    case SEQ(head, Seq()) => println("final")
    case SEQ(head, tail) => {
      println("recursing")
      doMatch(tail)
    }
  }
}

Answer 6

从 Seq 到 List 的简单转换就可以完成这项工作：

def doMatch (list: List[Int]): Unit = list match {           
    case last :: Nil => println ("Final element.")             
    case head :: tail => println ("Recursing..."); doMatch (tail)
    case Nil => println ("only seen for empty lists") 
  }

def doMatchSeq (seq: Seq[Int]) : Unit = doMatch (seq.toList)

doMatch (List(3, 4, 5))
doMatchSeq (3 to 5)