Question

我创建了一个Scala解析器组合器，根据前一个问题的答案过滤数据记录How to parse a string with filter citeria in scala and use it to filter objects

我想从这个问题的答案中添加计算器解析器组合器 Operator Precedence with Scala Parser Combinators 在我根据第一个问题创建的解析器组合器的底部。因此，计算器解析器组合器需要接受dataRecord，以便可以将类似“（doubleValue1 / 10）* 2 + doubleValue2”的表达式解析为随后可以获取dataRecord的函数。

这就是我提出的，但加号，减号，时间和除法解析器组合器现在已经被破坏，因为+ - * /运算符是Double的成员而不是函数DataRecord =＆gt;双。如何修复这些解析器组合器，以便可以成功解析像“（doubleValue1 / 10）* 2 + doubleValue2”这样的表达式并生成一个可以接受dataRecord的函数？

import scala.util.parsing.combinator._
import scala.util.parsing.combinator.JavaTokenParsers

object Main extends Arith with App {

  val dataRecord = new DataRecord(100, 75 )
  val input = "( doubleValue1 / 10   ) * 2 + doubleValue2"
  println(parseAll(arithmicExpr, input).get(dataRecord)) // prints 95
}

class DataRecord(  val doubleValue1 : Double,  val doubleValue2 : Double ) 

class Arith extends JavaTokenParsers {

  type D = Double
  type Extractor[Double] = DataRecord => Double


  //arithmic expression
  def arithmicExpr:       Parser[Extractor[D]]                = term ~ rep(plus | minus)     ^^ {case a~b => (a /: b)((acc,f) => f(acc))} 
  def plus:               Parser[Extractor[D]=>Extractor[D]]  = "+" ~ term                   ^^ {case "+"~b => _ + b}
  def minus:              Parser[Extractor[D]=>Extractor[D]]  = "-" ~ term                   ^^ {case "-"~b => _ - b}
  def term:               Parser[Extractor[D]]                = factor ~ rep(times | divide) ^^ {case a~b => (a /: b)((acc,f) => f(acc))}
  def times:              Parser[Extractor[D]=>Extractor[D]]  = "*" ~ factor                 ^^ {case "*"~b => _ * (b) }
  def divide:             Parser[Extractor[D]=>Extractor[D]]  = "/" ~ factor                 ^^ {case "/"~b => _ / b} 
  def factor:             Parser[Extractor[D]]                = fpn | "(" ~> arithmicExpr <~ ")" |  intExtractor 
  def fpn:                Parser[Extractor[D]]                = floatingPointNumber          ^^ (s => Function.const(s.toDouble)_)
  def intExtractor:       Parser[Extractor[D]]                = ("doubleValue1" | "doubleValue2")             ^^ {
    case "doubleValue1" => _.doubleValue1                                                                                             
    case "doubleValue2" => _.doubleValue2 
  }
}

Answer 1

你避免使用左递归语法的方法很好，但是这些类型非常复杂。我更喜欢不同的方法：

object ArithParser extends JavaTokenParsers {
  //arithmic expression
  def arithmicExpr:       Parser[Extractor[D]] = plus
  def plus:               Parser[Extractor[D]] = repsep(times, "+") ^^ { summands : List[Extractor[D]] =>
    (in : DataRecord) => summands.map((e : Extractor[D]) => e(in)).foldLeft(0d)(_ + _)
  }
  def times:              Parser[Extractor[D]] = repsep(division, "*") ^^ { factors : List[Extractor[D]] =>
    (in : DataRecord) => factors.map((e : Extractor[D]) => e(in)).foldLeft(1d)(_ * _)
  }

  def division :           Parser[Extractor[D]] = rep1sep(number, "/") ^^ {divisons : List[Extractor[D]] =>
    (in : DataRecord) => divisons.map((e : Extractor[D]) => e(in)).reduce(_ / _)
  } | number
  def number :            Parser[Extractor[D]] = fpn | intExtractor
  def fpn:                Parser[Extractor[D]] = floatingPointNumber          ^^ (s => Function.const(s.toDouble)_)
  def intExtractor:       Parser[Extractor[D]] = ("doubleValue1" | "doubleValue2")             ^^ {
    case "doubleValue1" => _.doubleValue1
    case "doubleValue2" => _.doubleValue2
  }
}

您可以找到live demo here。

此代码可以进一步改进：它包含许多重复结构。也许这对Stack exchange的代码审查网站来说是个好例子。

其他算术运算符，数学函数，尤其是大括号的增强功能是直截了当的。

Scala解析器基于组合器的计算器，也可以采用dataRecord

1 个答案: