如何动态地组合Scala的解析器组合器功能？

Question

如何动态地组合Scala的解析器组合器功能？

3

我正在寻找一种动态组合Scala解析器组件的函数。例如，如果我想静态地完成这个任务，我可以编写以下代码：

def aDirective: Parser[String] = "a" ^^ { case _ => "a" }
def bDirective: Parser[String] = "b" ^^ { case _ => "b" }

def combinedDirective: Parser[List[String]] =
  aDirective ~ bDirective ^^ { case a ~ b => List(a, b) }

但是，我希望能够以动态方式编写此代码，以生成解析器的组合。

例如：

def aDirective: Parser[String] = "a" ^^ { case _ => "a" }
def bDirective: Parser[String] = "b" ^^ { case _ => "b" }

def combinedDirective: Parser[List[String]] =
  combine(List(aDirective, bDirective))

def combine(parsers: List[Parser[T]): Parser[List[T]] = ???

我认为我需要从一个解析器列表转换为结果列表的解析器。因此，我尝试编写了一个名为“combine”的函数的签名。

目前，我无法想出如何实现“combine”函数。无论我怎么尝试，似乎都存在一些问题，我暂时想不出如何解决。例如，如何构建折叠的初始解析器？我已经尝试过各种foldLeft和reduceLeft结构的实验，但似乎总是无法达到预期的效果。

我正在使用Scala 2.11。有什么想法吗？

- adamretter

1个回答

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- Travis Brown · Accepted Answer

这是一个序列化操作，而Scalaz提供了一种快捷方式（通常情况下，你不需要使用Scalaz的显式实例定义模板，但这是一个特殊情况）：

import scala.util.parsing.combinator.RegexParsers
import scalaz._, Scalaz._

object MyParser extends RegexParsers {
  implicit val pm = std.util.parsing.combinator.parser.parserMonad(this)

  def aDirective: Parser[String] = "a" ^^ { case _ => "a" }
  def bDirective: Parser[String] = "b" ^^ { case _ => "b" }

  def combine[T](parsers: List[Parser[T]]): Parser[List[T]] = parsers.sequenceU

  def combinedDirective: Parser[List[String]] =
    combine(List(aDirective, bDirective))
}

接下来：

scala> MyParser.parseAll(MyParser.combinedDirective, "ab")
res0: MyParser.ParseResult[List[String]] = [1.3] parsed: List(a, b)

你可以使用fold自定义它：

import scala.util.parsing.combinator.RegexParsers

object MyParser extends RegexParsers {
  def aDirective: Parser[String] = "a" ^^ { case _ => "a" }
  def bDirective: Parser[String] = "b" ^^ { case _ => "b" }

  def combine[T](parsers: List[Parser[T]]): Parser[List[T]] =
    parsers.foldRight(success(List.empty[T])) {
      case (p, acc) => for {
        pRes   <- p
        accRes <- acc
      } yield pRes :: accRes
    }

  def combinedDirective: Parser[List[String]] =
    combine(List(aDirective, bDirective))
}

它的功能完全相同。诀窍就是正确地设置基础，它需要是一个解析器，总是以空列表作为其值成功。

更新：如果您正在定义一个类而不是对象，则上述Scalaz方法将无法正常工作（由于许多奇怪的原因——简而言之，this不够稳定）。不过，您可以轻松地定义自己的monad实例：

class MyParser extends RegexParsers {
  implicit val pm = new Monad[Parser] {
    def point[A](a: => A): Parser[A] = success(a)
    def bind[A, B](fa: Parser[A])(f: A => Parser[B]): Parser[B] = fa flatMap f
  }

  def aDirective: Parser[String] = "a" ^^ { case _ => "a" }
  def bDirective: Parser[String] = "b" ^^ { case _ => "b" }

  def combine[T](parsers: List[Parser[T]]): Parser[List[T]] = parsers.sequenceU

  def combinedDirective: Parser[List[String]] =
    combine(List(aDirective, bDirective))
}

在这里使用sequence，你实际上不需要一个单子实例，只需要一个应用函子即可，但是定义实际上更加方便，并且单子实例可能在其他情况下很有用。