Question

void whatever() {
  // ...
  val parser = new MyParser
  val parse = parser.parse(input)
  if (parse successful) {
    semanticAnalysis(parse)
  }
}

void semanticAnalysis(parse: DontKnowTheCorrectType) {
  // ...
}

What type do I have to give to the formal parameter parse? Hovering over parse inside whatever says val parse: parser.ParseResult[parsing.Program], but of course that doesn’t work as a parameter type of semanticAnalysis, because the local variable parse is not in scope there.

Answer 1

Parse results are path-dependent types because they are results of this specific parser and there’s no guarantee they are compatible.

This is why parsers are usually not instantiated the way you use them (new MyParser), but as object.

object MyParser extends RegexParsers { 
   def statements : Parser[List[Statement]] = // ...
} 

def handleResult(res: MyParser.ParseResult[List[Statement]]) = { // ... } 

val res = MyParser.parseAll(MyParser.statements, "/* */")

If you need more dynamic behaviour (or want concurrent parsing, parser combinators aren’t thread-safe, ouch), you’ll just have to keep the parser object accessible (and stable) wherever you want to use its results.

Sadly, passing a parser and its result around together is not trivial because you run into the prohibition of dependent method types, e.g.

  def fun(p: scala.util.parsing.combinator.Parsers, res: p.ParseResult[_]) = {}

won’t compile (“illegal dependent method type”), but there are ways to get around that if you must, like the answer to this question.