7

我正在编写一个将接受各种“命令”字符串的应用程序。我一直在查看 Scala 组合器库来标记命令。我发现在很多情况下我想说：“这些标记是无序的集合，因此它们可以按任何顺序出现，有些可能不会出现”。

以我目前的语法知识，我将不得不定义所有序列组合（伪语法）：

command = action~content
action = alphanum
content  = (tokenA~tokenB~tokenC | tokenB~tokenC~tokenA | tokenC~tokenB~tokenA ....... )

所以我的问题是，考虑到 tokenA-C 是独一无二的，是否有更短的方法来使用语法定义一组任意顺序？

4

5 回答 5

4

您可以使用“解析器。^？” 运算符来检查一组解析元素的重复项。

  def tokens = tokenA | tokenB | tokenC
  def uniqueTokens = (tokens*) ^? (
    { case t if (t == t.removeDuplicates) => t },
    { "duplicate tokens found: " + _ })

这是一个示例，允许您以任意顺序输入四个 stooges 中的任何一个，但如果遇到重复则无法解析：

package blevins.example

import scala.util.parsing.combinator._  

case class Stooge(name: String)

object StoogesParser extends RegexParsers {
  def moe = "Moe".r
  def larry = "Larry".r
  def curly = "Curly".r
  def shemp = "Shemp".r
  def stooge = ( moe | larry | curly | shemp ) ^^ { case s => Stooge(s) }
  def certifiedStooge = stooge | """\w+""".r ^? (
    { case s: Stooge => s },
    { "not a stooge: " + _ })

  def stooges = (certifiedStooge*) ^? (
    { case x if (x == x.removeDuplicates) => x.toSet },
    { "duplicate stooge in: " + _ })

  def parse(s: String): String = {
    parseAll(stooges, new scala.util.parsing.input.CharSequenceReader(s)) match {
      case Success(r,_) => r.mkString(" ")
      case Failure(r,_) => "failure: " + r
      case Error(r,_) => "error: " + r
    }
  }

}

还有一些示例用法：

package blevins.example

object App extends Application {

  def printParse(s: String): Unit = println(StoogesParser.parse(s))

  printParse("Moe Shemp Larry")
  printParse("Moe Shemp Shemp")
  printParse("Curly Beyonce")

  /* Output:
     Stooge(Moe) Stooge(Shemp) Stooge(Larry)
     failure: duplicate stooge in: List(Stooge(Moe), Stooge(Shemp), Stooge(Shemp))
     failure: not a stooge: Beyonce
  */
}
于 2009-11-23T23:11:43.763 回答
3

有办法解决它。例如，看看这里的解析器。它接受 4 个预定义的数字，它们可以出现在任何其他数字中，但必须出现一次，而且只能出现一次。

OTOH，如果这种模式经常发生，您可以编写一个组合器：

def comb3[A](a: Parser[A], b: Parser[A], c: Parser[A]) =
  a ~ b ~ c | a ~ c ~ b | b ~ a ~ c | b ~ c ~ a | c ~ a ~ b | c ~ b ~ a
于 2009-11-23T11:09:40.270 回答
1

我不会尝试在语法上强制执行此要求。我会编写一个允许集合中允许多个标记的产品，然后使用非解析方法来确定实际给出的关键字的可接受性。除了允许更简单的语法之外，它还允许您在发出有关错误用法的诊断后更轻松地继续解析。

兰德尔·舒尔茨

于 2009-11-23T14:40:45.633 回答
0

如果您经常遇到这种情况，您当然可以编写一个组合规则来为您执行此操作。

另一方面，也许存在使“tokenA..C”只是“token”的选项，然后在“token”的处理程序内部进行区分

于 2009-11-23T08:11:32.000 回答
0

我不知道您要支持哪种结构，但我认为您应该指定更具体的语法。从您的评论到另一个答案：

待办事项消息：将待办事项类链接到数据库

我猜你不想接受类似的东西

todo message:database todo to link class

所以你可能想定义一些消息级别的关键字，比如“link”和“to”......

def token = alphanum~':'~ "link" ~ alphanum ~ "class" ~ "to" ~ alphanum 
  ^^ { (a:String,b:String,c:String) => /* a == "message", b="Todo", c="database" */ }

我猜你必须在那个级别定义你的语法。

于 2009-11-23T10:59:45.447 回答