Scala 将解析器[Any]转换为更严格的类型

Scala第33章中的编程说明：

它提供了以下示例：

  import scala.util.parsing.combinator._

  class Arith extends JavaTokenParsers {   
    def expr: Parser[Any] = term~rep("+"~term | "-"~term)
    def term: Parser[Any] = factor~rep("*"~factor | "/"~factor)
    def factor: Parser[Any] = floatingPointNumber | "("~expr~")"
  }

如何将

expr

映射到比

Parser[Any]

更窄的类型？换句话说,

我想使用

def expr:Parser[Any]

并通过

^

将其映射为更严格的类型

---

注意-我在Scala Google Group中问了这个问题，但还没有得到一个完整的答案来帮助我

如评论中所述，您可以将类型缩小为您喜欢的任何类型。您只需在

^^

之后指定它

下面是一个完整的示例，其中包含来自给定代码的数据结构

object Arith extends JavaTokenParsers {

  trait Expression //The data structure
  case class FNumber(value: Float) extends Expression
  case class Plus(e1: Expression, e2: Expression) extends Expression
  case class Minus(e1: Expression, e2: Expression) extends Expression
  case class Mult(e1: Expression, e2: Expression) extends Expression
  case class Div(e1: Expression, e2: Expression) extends Expression

  def expr: Parser[Expression] = term ~ rep("+" ~ term | "-" ~ term) ^^ {
    case term ~ rest => rest.foldLeft(term)((result, elem) => elem match {
      case "+" ~ e => Plus(result, e)
      case "-" ~ e => Minus(result, e)
    })
  }

  def term: Parser[Expression] = factor ~ rep("*" ~ factor | "/" ~ factor) ^^ {
    case factor ~ rest => rest.foldLeft(factor)((result, elem) => elem match {
      case "*" ~ e => Mult(result, e)
      case "/" ~ e => Div(result, e)
    })
  }

  def factor: Parser[Expression] = floatingPointNumber ^^ (f => FNumber(f.toFloat)) | "(" ~> expr <~ ")"

  def parseInput(input: String): Expression = parse(expr, input) match {
    case Success(ex, _) => ex
    case _ => throw new IllegalArgumentException //or change the result to Try[Expression]
  }
}

---

当然，您也可以使用

解析器[String]

或

解析器[Float]

，在这里您可以直接转换或计算输入字符串。正如我对你说的那样。

如评论中所述，你可以将类型缩小到你喜欢的任何类型。您只需在

^^

之后指定它

下面是一个完整的示例，其中包含来自给定代码的数据结构

object Arith extends JavaTokenParsers {

  trait Expression //The data structure
  case class FNumber(value: Float) extends Expression
  case class Plus(e1: Expression, e2: Expression) extends Expression
  case class Minus(e1: Expression, e2: Expression) extends Expression
  case class Mult(e1: Expression, e2: Expression) extends Expression
  case class Div(e1: Expression, e2: Expression) extends Expression

  def expr: Parser[Expression] = term ~ rep("+" ~ term | "-" ~ term) ^^ {
    case term ~ rest => rest.foldLeft(term)((result, elem) => elem match {
      case "+" ~ e => Plus(result, e)
      case "-" ~ e => Minus(result, e)
    })
  }

  def term: Parser[Expression] = factor ~ rep("*" ~ factor | "/" ~ factor) ^^ {
    case factor ~ rest => rest.foldLeft(factor)((result, elem) => elem match {
      case "*" ~ e => Mult(result, e)
      case "/" ~ e => Div(result, e)
    })
  }

  def factor: Parser[Expression] = floatingPointNumber ^^ (f => FNumber(f.toFloat)) | "(" ~> expr <~ ")"

  def parseInput(input: String): Expression = parse(expr, input) match {
    case Success(ex, _) => ex
    case _ => throw new IllegalArgumentException //or change the result to Try[Expression]
  }
}

---

当然，您也可以使用

解析器[String]

或

解析器[Float]

，在这里您可以直接转换或计算输入字符串。正如我对你说的那样。

如评论中所述，你可以将类型缩小到你喜欢的任何类型。您只需在

^^

之后指定它

下面是一个完整的示例，其中包含来自给定代码的数据结构

object Arith extends JavaTokenParsers {

  trait Expression //The data structure
  case class FNumber(value: Float) extends Expression
  case class Plus(e1: Expression, e2: Expression) extends Expression
  case class Minus(e1: Expression, e2: Expression) extends Expression
  case class Mult(e1: Expression, e2: Expression) extends Expression
  case class Div(e1: Expression, e2: Expression) extends Expression

  def expr: Parser[Expression] = term ~ rep("+" ~ term | "-" ~ term) ^^ {
    case term ~ rest => rest.foldLeft(term)((result, elem) => elem match {
      case "+" ~ e => Plus(result, e)
      case "-" ~ e => Minus(result, e)
    })
  }

  def term: Parser[Expression] = factor ~ rep("*" ~ factor | "/" ~ factor) ^^ {
    case factor ~ rest => rest.foldLeft(factor)((result, elem) => elem match {
      case "*" ~ e => Mult(result, e)
      case "/" ~ e => Div(result, e)
    })
  }

  def factor: Parser[Expression] = floatingPointNumber ^^ (f => FNumber(f.toFloat)) | "(" ~> expr <~ ")"

  def parseInput(input: String): Expression = parse(expr, input) match {
    case Success(ex, _) => ex
    case _ => throw new IllegalArgumentException //or change the result to Try[Expression]
  }
}

---

当然，您也可以使用

解析器[String]

或

解析器[Float]

，在这里您可以直接转换或计算输入字符串。正如我对你说的那样。

如评论中所述，你可以将类型缩小到你喜欢的任何类型。您只需在

^^

之后指定它

下面是一个完整的示例，其中包含来自给定代码的数据结构

object Arith extends JavaTokenParsers {

  trait Expression //The data structure
  case class FNumber(value: Float) extends Expression
  case class Plus(e1: Expression, e2: Expression) extends Expression
  case class Minus(e1: Expression, e2: Expression) extends Expression
  case class Mult(e1: Expression, e2: Expression) extends Expression
  case class Div(e1: Expression, e2: Expression) extends Expression

  def expr: Parser[Expression] = term ~ rep("+" ~ term | "-" ~ term) ^^ {
    case term ~ rest => rest.foldLeft(term)((result, elem) => elem match {
      case "+" ~ e => Plus(result, e)
      case "-" ~ e => Minus(result, e)
    })
  }

  def term: Parser[Expression] = factor ~ rep("*" ~ factor | "/" ~ factor) ^^ {
    case factor ~ rest => rest.foldLeft(factor)((result, elem) => elem match {
      case "*" ~ e => Mult(result, e)
      case "/" ~ e => Div(result, e)
    })
  }

  def factor: Parser[Expression] = floatingPointNumber ^^ (f => FNumber(f.toFloat)) | "(" ~> expr <~ ")"

  def parseInput(input: String): Expression = parse(expr, input) match {
    case Success(ex, _) => ex
    case _ => throw new IllegalArgumentException //or change the result to Try[Expression]
  }
}

---

当然，您也可以使用

解析器[String]

或

解析器[Float]

，在这里您可以直接转换或计算输入字符串。正如我对您说过的。

您通常使用解析器将

字符串

映射到数据结构的实例。这里的数据结构是什么？然后，

Any

可以被这种结构的类型替换。是的，你不能简单地用另一种类型替换Any并让你返回那种类型的东西吗？@Kigyo，我希望答案中有AST:）你通常使用解析器将

字符串

映射到数据结构的实例。这里的数据结构是什么？然后，

Any

可以被这种结构的类型替换。是的，你不能简单地用另一种类型替换Any并让你返回那种类型的东西吗？@Kigyo，我希望答案中有AST:）你通常使用解析器将

字符串

映射到数据结构的实例。这里的数据结构是什么？然后，

Any

可以被这种结构的类型替换。是的，你不能简单地用另一种类型替换Any并让你返回那种类型的东西吗？@Kigyo，我希望答案中有AST:）你通常使用解析器将

字符串

映射到数据结构的实例。这里的数据结构是什么？然后，

任何

都可以被这种结构的类型替换。是的，你不能简单地用另一种类型替换任何，然后让你返回那种类型的东西吗…？@Kigyo，我希望答案中有AST:）非常感谢！我认为这篇文章将提高这个例子中Scala文档的质量。非常感谢！我认为这篇文章将提高这个例子中Scala文档的质量。非常感谢！我认为这篇文章将提高这个例子中Scala文档的质量。非常感谢！我认为这篇文章将提高这个特定示例中Scala文档的质量。