Pratt Parser

A Pratt parser (or top-down operator precedence parser) is a variant of recursive descent parsing that handles operator precedence and associativity without encoding them in the grammar. Instead of a separate grammar rule for each precedence level — the conventional approach that multiplies grammar size by precedence depth — the Pratt parser uses a table of binding powers and a single recursive function that parses expressions at a given minimum precedence level.

The technique was developed by Vaughan Pratt in 1973 and is notable for its economy: a complete expression parser can be written in a few dozen lines of code. Languages from JavaScript to Lua to Swift use Pratt parsing or variants for their expression syntax. The parser's central insight is that precedence is not a syntactic property to be encoded in grammar rules but a semantic property to be consulted during parsing — a separation that makes the parser more compact and more easily extended with new operators.

The Pratt parser demonstrates that the limitations of recursive descent are not absolute boundaries but invitations to structural innovation. Where a naive recursive descent parser chokes on precedence-encoded grammars, the Pratt parser absorbs the complexity into a lookup table and a single recursive loop. It is recursive descent's answer to the precedence problem — and it is more elegant than the grammar-transformed alternative.

See also: Recursive Descent Parsing, Operator Precedence, Expression Parsing, Binding Power, Top-Down Parsing

Pratt Parsing and the Separation of Concerns

The Pratt parser is not merely a parsing technique; it is an architectural statement about the relationship between syntax and semantics. Conventional parsing theory treats operator precedence as a syntactic property — something to be encoded in grammar rules, transformed through left-factoring, and verified through parser-generators. The Pratt parser rejects this framing. It treats precedence as a semantic property, consultable at parse time through a table of binding powers, and thereby separates the grammar of expressions from the semantics of their evaluation.

This separation has consequences beyond compiler construction. It is an instance of a broader design pattern: the displacement of complexity from structural rules into data structures. Where a conventional approach multiplies grammar rules by precedence levels, the Pratt approach concentrates the complexity in a single table. The grammar becomes simpler; the table becomes the locus of semantic knowledge. This is the same move that table-oriented programming makes at the language level: replace specialized mechanisms with a universal data structure and derive behavior through lookup and composition.

Languages that adopt Pratt parsing — JavaScript, Lua, Swift — tend to share a design philosophy: minimize the kernel, maximize the expressive power of composition. The Pratt parser is the parsing equivalent of this philosophy. It says: do not encode your semantics in your grammar. Keep the grammar simple. Put the semantics in a table. Let the parser consult the table. The result is not just a smaller parser; it is a parser that can be extended at runtime with new operators, new precedence levels, and new associativities without regenerating the grammar or recompiling the parser. The Pratt parser is, in this sense, a dynamically dispatching parser — a parser whose behavior is determined by data, not by static structure.

The Pratt parser's enduring relevance is not that it solves the precedence problem. It is that it dissolves the problem by reframing it. Precedence ceases to be a syntactic burden and becomes a semantic resource — a table that can be queried, extended, and reasoned about independently of the grammar that uses it. This is not a parsing trick. It is a paradigm shift, and it recurs wherever systems designers confront the choice between encoding behavior in structure or in data. The Pratt parser chooses data — and in that choice, it anticipates the table-driven, configuration-over-code architectures that dominate modern software engineering.