Scala 中列表的模式匹配末尾/中间

Question

简单的解决方案来解决以下代码（它正在展开给定结构 0xFC :: len :: Payload :: ... :: 0x0A :: 0x0D 的整数列表）：

object Payload {
  def unapply(z: List[Int]): Option[List[Int]] = if (z.length == z.head + 1) Some(z tail) else None
}

object EndToken {
  def unapply(z: List[Int]): Option[List[Int]] = z.reverse match {
    case 0x0D :: 0x0A :: tail => Some(tail.reverse)
    case _ => None
  }
}

object Message {
  def unapply(z: List[Int]): Option[List[Int]] = z match {
    case 0xFC :: EndToken(x) => Some(x)
    case _ => None
  }
}

object Main extends App {
  val x = List(0xFC, 0x03, 0x01, 0x02, 0x03, 0x0A, 0x0D)

  x match {
    case Message(Payload(payload)) => println (payload)
    case _ => println("No match")
  }
}

有人可以给我一个更 就像：

object Message {
  def unapply(z: List[Int]): Option[List[Int]] = z match {
    case 0xFC :: Payload(x) :: 0x0A :: 0x0D => Some(x)
    case _ => None
  }
}

但是，当然， :: 需要的是元素，而不是列表，所以它不起作用......

Answer 1

这是我的解决方案（尽管重新阅读后我认为这就像丹尼尔的解决方案）。它基于中缀操作模式，其中模式 op(p, q) 与 p op q 相同。

该运算符以 : 开头，与 :: 具有相同的优先级，以 : 结尾，与右侧关联。 (len, Payload) :!: tail 与 :!:((len, Payload), tail) 相同。基于长度的有效负载提取的实现有点复杂，但主要是因为我只想遍历列表一次。

object :!: {
  type LengthPayload = (Int, List[Int]) // (len, payload)
  // returns ((len, payload), unparsed)
  def unapply(z: List[Int]): Option[(LengthPayload, List[Int])] = {
    if (z == Nil) None 
    else {
      val len = z.head
      // use ListBuffer to traverse the list only once
      val buf = collection.mutable.ListBuffer[Int]()
      def take(l: Int, list: List[Int]): Option[(LengthPayload, List[Int])] = {
        list match {
          case Nil if l > 0 => None
          case _ if l == 0 => Some((len, buf.toList), list)
          case _ => buf += list.head; take(l - 1, list.tail)
        }
      }
      take(len, z.tail)
    }
  }
}

然后消息变得更简单（视觉上）：

object Message {
  def unapply(z: List[Int]): Option[List[Int]] = z match {
    case 0xFC :: (len, payload) :!: 0x0A :: 0x0D :: Nil => Some(payload)
    case _ => None
  }
}

结果：

val x = List(0xFC, 0x03, 0x01, 0x02, 0x03, 0x0A, 0x0D)
x match {
  case Message(payload) => println(payload)
  case _ => println("No match")
}
// List(1, 2, 3)

Answer 2

Scala 现在使用“:+”库对象支持序列末尾的模式匹配。我不确定这个功能是什么时候添加的，但我在 Dean Wampler 和 Alex Payne 的《Programming Scala》第二版中读到了它。下面是一个检索列表中最后一个元素的字符串的简单示例：

def stringOfLastElement[T](list: List[T]): String = list match {
    case prefix :+ end => end.toString
    case Nil => "Nil"
}

Answer 3

您可以在此处利用一些语法糖进行模式匹配：

case a Pattern b => ... 

与以下相同：

case Pattern(a, b) => ...

因此，如果您像这样修改 EndToke 提取器：

object EndToken {
  def unapply(xs: List[Int]): Option[(List[Int], List[Int])] =
    (xs takeRight 2) match {
        case suffix @ (_ :: _ :: Nil) => Some((xs dropRight 2, suffix))
        case _ => None
    }
}

您可以在如下模式中使用它：（

case 1 :: 2 :: (payload EndToken (0xFF :: OxCC :: Nil)) => ...

抱歉，我不记得优先级规则了手，所以其中一些括号可能是不必要的。）

Answer 4

您不能将参数传递给匹配项，除非隐式传递，并且提取器必须知道它需要提取什么。

人们无法真正简化您的解决方案。这是另一种编写方式，但这更多的是偏好问题。

object :>>: {
  def unapply(xs: List[Int])(implicit size: Int): Option[(List[Int], List[Int])] = 
    if (xs.size >= size) Some(xs splitAt size)
    else None
}

object :<<: {
  def unapply(xs: List[Int]): Option[(List[Int], List[Int])] = xs match {
    case size :: rest =>
      implicit val len = size
      rest match {
        case payload :>>: tail => Some((payload, tail))
        case _ => None
      }
    case _ => None
  }
}

object Message {
  def unapplySeq(xs: List[Int]): Option[List[Int]] = xs match {
    case 0xFC :: payload :<<: 0x0A :: 0x0D :: Nil => Some(payload)
    case _ => None
  }
}

编辑：注意方法 :<<: 和 :>>: 上的冒号。在此代码中，后者实际上并不需要它们，但前者需要它们。

标识符末尾的冒号表示左关联性和右关联性。这很重要，因为 :: 和 :<<: 右侧的参数必须是 List，但 0x0A 和 0x0D 不是列表。然而，右结合性意味着首先应用最右边的运算符，然后应用左边的运算符。换句话说。 0x0A :: (0x0D :: Nil) 而不是 (0x0A :: 0x0D) :: Nil。

由于优先级，标识符开头的冒号是必需的。即使具有右关联性，错误的优先级也会将 0xFC :: Payload <<: ... 变为 (0xFC :: Payload) <<: ...代码>.

请注意，我使用 unapplySeq 在 Message 中返回结果，以便可以像在 List 中一样提取结果。然而，这意味着您需要 @ _* 来获取整个序列：

scala> List(0xFC, 0x03, 0x01, 0x02, 0x03, 0x0A, 0x0D) match {
     |   case Message(z @ _*) => println (z)
     |   case _ => println("No match")
     | }
List(1, 2, 3)