为什么RegexParsers用“ def”而不是“ lazy val”来定义？

Question

In the Scaladoc about RegexParsers , there is the following code:

object Calculator extends RegexParsers {
  def number: Parser[Double] = """\d+(\.\d*)?""".r ^^ { _.toDouble }
  def factor: Parser[Double] = number | "(" ~> expr <~ ")"
...

I don't see why we it's written with a def and not with a val or a lazy val ? I would write like this :

object Calculator extends RegexParsers {
  lazy val number: Parser[Double] = """\d+(\.\d*)?""".r ^^ { _.toDouble }
  lazy val factor: Parser[Double] = number | "(" ~> expr <~ ")"
...

Answer 1

There is an actual semantic reason for it. Look at the type signature for Parser :

 abstract class Parser[+T] extends (Input) ⇒ ParseResult[T]

Parser[T] is in fact a function from some abstract kind of Input to a ParseResult[T] . In many (probably most) cases this function captures some aspect of the state of the parse being carried out. If such a production were captured in a val , (lazy or otherwise) it could not be used in more than one place in a given parse tree. The only productions that can be made val are fixed terminals such as punctuation and keywords.

Addendum

It has been years since I've worked on Scala combinator parsers and I was comparatively a Scala newbie at the time, so it's entirely possible I was simply mistaken. However, my recollection is that that Reader represented not the input as a whole but rather a specific sub-sequence of that input. Thus if the production did not have a fixed input sequence, the production could not be a val .

I actually do have a little side project that needs a parser, so when I get some time, I can either confirm or refute that understanding.