[EdSchouten]

What I find annoying about using parser generators is that it always feels messy integrating the resulting parser into your application. So you write a file that contains the grammar and generate a parser out of that. Now you build it into your app and call into it to parse some input file, but that ends up giving you some poorly typed AST that is cluttered/hard to work with.

Certain parser generators make life easier by supporting actions on parser/lexer rules. This is great and all, but it has the downside that the grammar you provide is no longer reusable. There's no way for others to import that grammar and provide custom actions for them.

I don't know. In my opinion parsing theory is already solved. Whether it's PEG, LL, LR, LALR, whatever. One of those is certainly good enough for the kind of data you're trying to parse. I think the biggest annoyance is the tooling.

[mrkeen]

Parser combinators is what I've been loving in the last few years.

Pros: * They're just a technique/library that you can use in your own language without the seperate generation step.

* They're simple enough that I often roll my own rather than using an existing library.

* They let you stick code into your parsing steps - logging, extra information, constructing your own results directly, e.g.

* The same technique works for lexing and parsing - just write a parser from bytes to tokens, and a second parser from tokens to objects.

* Depending on your languages syntax, you can get your parser code looking a lot like the bnf grammar you're trying to implement.

Cons: * You will eventually run into left-recursion problems. It can be nightmarish trying to change the code so it 'just works'. You really need to step back and grok left-recursion itself - no handholding from parser combinators.

* Same thing with precedence - you just gotta learn how to do it. Fixing left-recursion didn't click for me until I learned how to do precedence.