3 ms·
Well, IMO, but you write a parser only a couple of times for each language, but you read code all the time. So, anything that makes code easier to read is a mu
by marcosdumay 3y ago
Well, IMO, but you write a parser only a couple of times for each language, but you read code all the time.
So, anything that makes code easier to read is a must. That includes the extra expressiveness of an LR grammar.
- mhh__ 3y agoIn 2012 yes, but these days having grammars that lots of tools can parse and output easily is a boon for tooling.
- vidarh 3y agoI agree there are a few places like this, but they're usually solved when you want an LL parser for as much as possible of the language by either making them part of the tokenization or by "escaping" a small subset of the grammar. I wish that language designers (looking at you, Ruby - as much as I love using Ruby, the grammar is an abomination) would at least try to stick to LL as much as possible, and consciously, carefully and in a limited fashion "escape" into LR for as small subsets as possible. Break rules if it actually helps developers, sure, but it'd be nice if people tried to make the weird bits as tiny as possible... EDIT: Also, in practice this is often what we end up doing when we write recursive descent anyway, only in a less than formal way. It'd be nice if more tooling let us write grammars that default to LL w/checking, but let you insert clearly delineated exceptions.
- marcosdumay 3y agoOh, I do agree with that! A language should be LL as much as possible. And also depend on the parsed data as little as possible. Stuff like C's variable declaration must be avoided. But I don't think either of those rules can be made universal. Some language for expressing exceptions would be great.
- haberman 3y agoDo you know of any particularly readable constructs that are possible with LR but incompatible with LL? My general opinion is that any constructs that confuse a parser will also confuse a human.
- marcosdumay 3y agoOperators with precedence rules. And given the modern idea of "everything is either an identifier or an operator", precedence became very important.
- haberman 3y agoOperators with precedence rules frequently appear in top-down parsers. I agree that pure-LL form doesn't make this easy, but most languages I have seen use Pratt parsers that allow precedence parsing within a top-down framework. It doesn't require full LR.
- Rusky 3y agoPratt parsing is essentially hand-written LR. It's certainly bottom-up in the same way, despite Pratt's paper title. (I went into more depth on this a few years ago: https://www.abubalay.com/blog/2021/12/31/lr-control-flow https://www.abubalay.com/blog/2021/12/31/lr-control-flow)
- chubot 3y agoHm I wouldn't call it bottom up -- I would say it's top down, but you consult a table of integers to decide where to recurse. I would even call it a variant of recursive descent, which is top-down. In plain recursive descent, you often choose where to recurse based on the first token (e.g. if while for). In Pratt, you choose based on a table indexed by the second operater token. You can have an an entire arbitrary length subexpression before the "second token", but it is still resolved "eagerly". e.g. consulting the loop here - https://github.com/andychu/pratt-parsing-demo/blob/master/tdop.py#L212 https://github.com/andychu/pratt-parsing-demo/blob/master/td... I skimmed over your post, but I don't really see the bottom-up argument. I guess I could concede that it's neither top down nor bottom up, but I don't see the argument for being bottom up. And maybe this is just a taxonomy thing, which doesn't matter in practice. It could be understood both ways -- I don't think Vaughan Pratt was mistaken when he understood it a certain way :) --- "where to recurse" is basically choosing the parent's production before its children -- that's most similar to top down If you choose the child's production before its parent, then that's LR / bottom-up (using Haberman's explanation - https://blog.reverberate.org/2013/07/ll-and-lr-parsing-demystified.html https://blog.reverberate.org/2013/07/ll-and-lr-parsing-demys...) May also be relevant: https://www.oilshell.org/blog/2017/03/31.html https://www.oilshell.org/blog/2017/03/31.html https://www.oilshell.org/blog/2017/04/22.html https://www.oilshell.org/blog/2017/04/22.html https://matklad.github.io/2020/04/15/from-pratt-to-dijkstra.html https://matklad.github.io/2020/04/15/from-pratt-to-dijkstra.... I believe some people claimed that Dijikstra is bottom-up and Pratt is top down. That has a certain nice symmetry to it, but I'm not sure it's true :) Dijikstra does use an explicit stack and Pratt uses the call stack -- maybe that is how I'd put it.