Basic question: how to best handle this case

Hi there, I have a very simple DSL that I’m writing a parser for. However, I’m having trouble coming up with an elegant solution.

The DSL looks like this:

foo
foo or bar
foo or bar or baz
(foo or bar) and baz

So the pattern is (ignoring nested expressions and assuming all tuples are of size 1 or 2):

const word = regex(/.*/)
const separator = alt(
  string('or'),
  string('and')
)
const expression = alt(
  seq(word, separator, word),
  word
)

However, word also matches or and and! Words can contain numbers, spaces, and special characters, so I can’t just make the regex more specific. What I ended up doing was adding a negative lookahead to the regex: (?! and )(?! or ).

Is there a more elegant way to express this, without resorting to negative lookaheads?

Thanks!

[wavebeem]

Something like this might be useful to you:

var util = require("util")
var P = require("parsimmon")
var _ = P.whitespace

function spaced(parser) {
  return _.then(parser).skip(_)
}

var Word =
  P.regex(/[^ ]+/).chain(w =>
    w === "and" || w === "or"
      ? P.fail("a word")
      : P.of({type: "string", value: w}))

var Phrase =
  P.sepBy1(Word, _).map(words => ({type: "phrase", words}))

var Connector =
  spaced(P.string("and").or(P.string("or")))

var ConnectedExpression =
  P.lazy(() => P.alt(
    P.seqMap(Phrase, Connector, ConnectedExpression, (l, m, r) =>
      ({connector: m, left: l, right: r})
    ),
    Phrase
  ))

var src = "foo bar and quux da$"
var res = ConnectedExpression.parse(src)
if (res.status) {
  console.log(util.inspect(res.value, {depth: null, colors: "auto"}))
} else {
  console.error(P.formatError(src, res))
}

Output

{ connector: 'and',
  left:
   { type: 'phrase',
     words:
      [ { type: 'string', value: 'foo' },
        { type: 'string', value: 'bar' } ] },
  right:
   { type: 'phrase',
     words:
      [ { type: 'string', value: 'quux' },
        { type: 'string', value: 'da$' } ] } }

If that looks useful, feel free to ask questions and I can dive into more detail later.

[wavebeem]

You’re welcome! Best of luck on your parser.