Write You a Haskell Stephen Diehl

Extended Parser
Up until now we’ve been using parser combinators to build our parsers. Parser combinators are a topdown
parser formally in the LL(k) family of parsers. e parser proceeds top-down, with a sequence of
k characters used to dispatch on the leftmost production rule. Combined with backtracking (i.e. try
combinator) this is simultaneously both an extremely powerful and simple model to implement as we
saw before with our simple 100 line parser library.
However there are a family of grammars that include left-recursion that LL(k) can be inefficient and often
incapable of parsing. Left-recursive rules are the case where the left-most symbol of the rule recurses on
itself. For example:
e ::= e op atom
Now we demonstrated a way before that we could handle these cases using the parser combinator
chainl1 function, and while this is possible sometimes it can in many cases be inefficient use of parser
stack and lead to ambiguous cases.
e other major family of parsers LR are not plagued with the same concerns over left recursion. On the
other hand LR parser are exceedingly more complicated to implement, relying on a rather sophisticated
method known as Tomita’s algorithm to do the heavy lifting. e tooling can around the construction of
the production rules in a form that can be handled by the algorithm is often handled a DSL that generates
the code for the parser. While the tooling is fairly robust, there is a level of indirection between us and
the code that can often be a bit of brittle to extend with custom logic.
e most common form of this toolchain is the Lex/Yacc lexer and parser generator which compile into
efficient C parsers for LR grammars. Haskell’s Happy and Alex are roughly the Haskell equivalent of
these tools.
Toolchain
Our parser logic will be spread across two different modules.
• Lexer.x
• Parser.y
e code in each of these modules is a hybrid of the specific Alex/Happy grammar syntax and arbitrary
Haskell logic that is spliced in. Code delineated by braces ({}) is regular Haskell, while code outside is
parser/lexer logic.
128