Scala 组合器解析器，>> 的作用是什么意思是？

Question

我对“>>”有点困惑在斯卡拉。 Daniel 在 Scala 解析器组合器解析 xml？ 中说它可以用于参数化解析器基于先前解析器的结果。有人能给我一些例子/提示吗？我已经读过 scaladoc 但仍然不明白。

谢谢

Answer 1

正如我所说，它用于参数化解析器，但让我们通过一个示例来清楚地说明这一点。

让我们从一个简单的解析器开始，它解析一个数字后跟一个单词：

def numberAndWord = number ~ word
def number        = "\\d+".r
def word          = "\\w+".r

在 RegexParsers，这将解析“3 个水果”之类的内容。

现在，假设您还想要这些“n 件事”的列表。例如，“3种水果：香蕉、苹果、橙子”。让我们尝试解析它，看看它是如何进行的。

首先，我如何解析“N”件事？碰巧，有一个 repN 方法：

def threeThings = repN(3, word)

它将解析“banana apple Orange”，但不会解析“banana, apple, Orange”。我需要一个分隔符。有 repsep 提供了这一点，但这不会让我指定我想要的重复次数。因此，让我们自己提供分隔符：

def threeThings = word ~ repN(2, "," ~> word)

好的，就是这样。我们现在可以为三件事编写整个示例，如下所示：

def listOfThings = "3" ~ word ~ ":" ~ threeThings
def word         = "\\w+".r
def threeThings  = word ~ repN(2, "," ~> word)

这种方法可行，只是我在 3 中修复了“N”。我想让用户指定有多少个。这就是 >> 的所在，也称为 into （是的，它是 Parser 的 flatMap ），进入。首先，让我们更改 thirdThings：

def things(n: Int) = n match {
  case 1          => word ^^ (List(_))
  case x if x > 1 => word ~ repN(x - 1, "," ~> word) ^^ { case w ~ l => w :: l }
  case x          => err("Invalid repetitions: "+x)
}

这比您预期的稍微复杂一些，因为我强制它返回 Parser[List[String]]。但是如何将参数传递给事物呢？我的意思是，这行不通：

def listOfThings = number ~ word ~ ":" ~ things(/* what do I put here?*/)

但我们可以这样重写：

def listOfThings = (number ~ word <~ ":") >> {
  case n ~ what => things(n.toInt)
}

这几乎足够好了，除了我现在丢失了 n 和 what：它只返回“列出（香蕉、苹果、橙子）”，而不是应该有多少，以及它们是什么。我可以这样做：

def listOfThings   = (number ~ word <~ ":") >> {
  case n ~ what => things(n.toInt) ^^ { list => new ~(n.toInt, new ~(what, list)) }
}
def number         = "\\d+".r
def word           = "\\w+".r
def things(n: Int) = n match {
  case 1          => word ^^ (List(_))
  case x if x > 1 => word ~ repN(x - 1, "," ~> word) ^^ { case w ~ l => w :: l }
  case x          => err("Invalid repetitions: "+x)
}

只是最后的评论。您可能想问自己“你的意思是 flatMap？这不是一个 monad/用于理解的东西吗？”为什么，是的，是的！ :-) 这是 listOfThings 的另一种编写方式：

def listOfThings   = for {
  nOfWhat  <- number ~ word <~ ":"
  n ~ what = nOfWhat
  list     <- things(n.toInt)
}  yield new ~(n.toInt, new ~(what, list))

我不做 n ~ What <- number ~ word <~ ":" 因为它使用 Scala 中的 filter 或 withFilter，它不是由 Parsers 实现的。但这里还有另一种编写方式，它不具有完全相同的语义，但会产生相同的结果：

def listOfThings   = for {
  n    <- number
  what <- word
  _    <- ":" : Parser[String]
  list <- things(n.toInt)
}  yield new ~(n.toInt, new ~(what, list))

这甚至可能让人认为“单子无处不在”的说法可能会有一些东西。 :-)

Answer 2

方法>>采用一个函数，该函数给出解析器的结果，并使用它来构造一个新的解析器。如前所述，这可用于根据前一个解析器的结果对解析器进行参数化。

示例

以下解析器解析包含 n + 1 整数值的行。第一个值n 表示要遵循的值的数量。解析第一个整数，然后使用该解析的结果构造一个解析器，该解析器解析 n 个进一步的整数。

解析器定义

以下行假设您可以使用 parseInt: Parser[Int] 解析整数。它首先解析一个整数值 n，然后使用 >> 解析形成解析器结果的 n 个附加整数。因此解析器不会返回初始的 n（尽管它是返回列表的大小）。

def intLine: Parser[Seq[Int]] = parseInt >> (n => repN(n,parseInt))

有效输入

1 42
3 1 2 3
0

无效输入

0 1
1
3 42 42