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

Question

我对scala中的“>>”有点困惑。 Daniel 在Scala parser combinators parsing 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)

这将解析“香蕉苹果橙”，而不是“香蕉，苹果，橙”。我需要一个分隔符。 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（是的，它是flatMap for Parser）的用武之地。首先我们改一下threeThings：

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：它只返回“List(banana, apple, orange)”，而不是应该有多少，以及它们是什么。我可以这样做：

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/for-comprehension 的东西吗？” 为什么，是的，是的！ :-) 这是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))

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

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