可变参数的 Scala 模式匹配

Question

我只是想动手实践一下 scala 并尝试自己实现 List.concat 函数。这是代码

  def concat[A](lists : Traversable[A]*):List[A]={
    println("concat called")
    lists match {
      case Nil => Nil
      case x :: Nil => (x :\ List.empty[A])((elem,list)=> elem::list)
      case x:: xs => (x :\ concat(xs:_*))((elem,list)=> elem :: list)
    }
  }

但是，当我尝试像

一样调用此方法时

concat(List(1,2,3),List(2,3,4),List(4,5,6),List(6,7,8))

我得到错误

Exception in thread "main" scala.MatchError: WrappedArray(List(1, 2, 3), List(2, 3, 4), List(4, 5, 6), List(6, 7, 8)) (of class scala.collection.mutable.WrappedArray$ofRef)

有人可以解释我在这里做错了什么吗？ 提前致谢

Answer 1

Varags 是 Seq，您可以像在 Seq 上一样匹配它，而不是像在列表上一样。这是一个例子：

@ a(1, 2, 3) 
res1: Seq[Int] = Array(1, 2, 3)
@ def a(x: Int*) = x match {
                  case Seq() => "empty"
                  case Seq(a) => s"single $a"
                  case Seq(a, as @ _*) => s"multiple: $a, $as"
                } 
defined function a
@ a(1, 2, 3, 4) 
res3: String = "multiple: 1, WrappedArray(2, 3, 4)"
@ a(1, 2) 
res4: String = "multiple: 1, WrappedArray(2)"
@ a(1) 
res5: String = "single 1"

对Nil 和x :: xs 进行此类匹配通常意味着您可以简单地使用foldLeft，它就是这样做的。

def concat[A](lists: Traversable[A]*): List[A] =
    lists.foldLeft(List.empty[A])(_ ++ _)

请注意，匹配Nil 和x :: xs，其中xs 可以是Nil，就足够了。您的第二个case 可以简单地删除。

看看那些：

case Nil => Nil
case x :: Nil => (x :\ List.empty[A])(_ :: _)
case x :: xs  => (x :\ concat(xs:_*))(_ :: _)

最后两个是一样的。如果在第三种情况下xs == Nil 则代替concat(xs:_*)，您将获得Nil，这与List.empty[A] 相同（如果类型推断正确）。

Answer 2

Nil 是List：

scala> Nil
res11: scala.collection.immutable.Nil.type = List()

但是，Scala 将所有可变参数包装到 Seq 中（WrappedArray 实现 Seq），这就是您得到 MatchError 的原因。您可以通过以下方式重写您的函数：

scala>   def concat[A](lists : Traversable[A]*):List[A]={
     |     lists match {
     |       case Seq() => Nil
     |       case x +: Seq() => (x :\ List.empty[A])((elem,list)=> elem::list)
     |       case x +: xs => (x :\ concat(xs:_*))((elem,list)=> elem :: list)
     |     }
     |   }
concat: [A](lists: Traversable[A]*)List[A]

scala> concat(List(1), List(2), List(3))
res9: List[Int] = List(1, 2, 3)

你也可以使用flatMap来简化你的函数：

scala> def concat[A](lists: Traversable[A]*): List[A] = {
     |     lists.flatMap(x => x).toList
     | }
concat: [A](lists: Traversable[A]*)List[A]

scala> concat(List(1), List(2), List(3))
res16: List[Int] = List(1, 2, 3)