Handling spaces between string keywords

[JD557]

(Discussed on Discord, posting here for future visibility)

It's common to have languages where it's desirable to support expressions like "true or false" without caring about the whitespace (e.g. true or false is also valid).

A simple solution would look like this:

import fastparse.MultiLineWhitespace._
import fastparse._

enum Expression:
  case Bool(value: Boolean)
  case Or(a: Expression, b: Expression)

trait Parser {
  def parse(str: String): Parsed[Expression]
}

object BadParser extends Parser {
  private def bool[$: P]: P[Expression] =
    P("true").map(_ => Expression.Bool(true)) | P("false").map(_ => Expression.Bool(false))

  private def or[$: P]: P[Expression] =
    P(bool ~ P("or") ~ bool).map((a, b) => Expression.Or(a, b))

  def parse(str: String): Parsed[Expression] =
    fastparse.parse(str, or(_))
}

However, this parser will also accept strings such as trueorfalse, which is usually undesirable.

The solution to this is to use either positive or negative lookahead.

Personally, I think negative lookahead it's a bit easier to use, as one only needs to enumerate the valid keyword characters.

In this case, it would look something like this:

object GoodParser extends Parser {
  // A keyword matches a string and checks the following character using negative lookahead
  private def keyword[$: P](str: String): P[Unit] = P(str ~~ !CharIn("A-Za-z0-9_\\-"))

  private def bool[$: P]: P[Expression] =
    keyword("true").map(_ => Expression.Bool(true)) | keyword("false").map(_ => Expression.Bool(false))

  private def or[$: P]: P[Expression] =
    P(bool ~ keyword("or") ~ bool).map((a, b) => Expression.Or(a, b))

  def parse(str: String): Parsed[Expression] =
    fastparse.parse(str, or(_))
}

I recommend using a helper like the keyword above, since this is something that can pop up in multiple places.

Scastie with the full example: https://scastie.scala-lang.org/e2xliCubRjiQZbdpinWNsA