Grammar presets.

[modulovalue]

Hello @mdaines,

(I hope you don't mind another issue)

I think it would be awesome if there was a way to load sample grammars (and perhaps make it easy to submit them via PRs?). I'm thinking of something like the "Load Sample" feature in edotor, but with a short description for why the grammar is considered to be interesting.

---

"Mysterious conflict"

Here's one grammar that I think is interesting source:

on grammophone

It demonstrates a grammar that is LALR(1), but not LR(1). The conflict is known as a "mysterious conflict".

[modulovalue]

Grammar examples

I've just found this: http://smlweb.cpsc.ucalgary.ca/example-grammars/ by chasing links starting at the readme of this project. This contains a bunch of grammar examples for various grammar classes.

[mdaines]

Yes, those would be good examples. They're already imported for test fixtures: https://github.com/mdaines/grammophone/blob/76612cb618f22fa7aaf9ec53f2ddefb6194f85b2/test/fixtures/example_grammars.js

[modulovalue]

Technique: Determinization via Unit Production Elimination

Here are two more that I think are interesting because they have practical relevance to e.g. parameter/argument lists that allow optional trailing commas:

This grammar attempts to capture interspersed lists where the separator can optionally occur at the end of the list.

The following grammar can be disambiguated by SLR(1): on grammophone

S -> L ','.
S -> L.
L -> L ',' a.
L  -> a.

The following grammar wraps the list from above in a separate production rule which makes it not LR(1): on grammophone

S -> P ','.
S -> P.
P -> L.
L -> L ',' a.
L  -> a.

A parser generator that naively transforms an "interspersion" construct to one with a level of indirection (like in the second grammar) would generate a grammar that is not LR(1).

[modulovalue]

Grammar examples

Here's a gist I found that contains more: https://gist.github.com/lin/dc83bb38eb458ded3ff01aec4a327d54

[modulovalue]

Testcase: unnecessary LR(1) splits

This grammar demonstrates a source of inefficiency in the automaton of the standard LR(1) construction.

Looking at the LR(1) automaton, I think that state 13 & 18 and state 17 & 12 could be merged and the resulting automaton would still resolve the ambiguity that LR(1) was meant to resolve. only 6 & 9 and 14 & 19 are required to be distinct new states.

This grammar is given as an example in some slides that introduce langcc. However, I'm not sure if langcc eliminates this source of inefficiency.

It appears that the act of eliminating this inefficiency is known as "minimizing" an LR automaton.

Edit: the author of the booze-tools project wrote a little something about this grammar: https://boozetools.readthedocs.io/en/latest/minimal.html

Note: Minimizing LR(1) State Machines is NP-Hard

[modulovalue]

Superseded by #26 (comment)

---

Transformation: Recursion Scheme Fusion

This grammar is LR(2), but can be easily converted to LR(1) by a procedure that heavily reminds me of recursion scheme fusion.

Source: "A grammar to recognise parameter lists"

---

(type_name id.','+).','+

two separate comma separated + lists:

• unfused on grammophone Not LR(1)
• fused: on grammophone SLR(1)

---

(type_name id.','*).','+

two separate comma separated lists where the outer list is + and the inner *:

• unfused: on grammophone Not LR(1)
• fused: on grammophone SLR(1)

[modulovalue]

Testcase: NQLALR guard

Here are two other interesting grammars:

When implementing an LALR parser using the Deremer and Pennello relation-based algorithm, it is easy to implement something that is known as NQLALR (Not-Quite-LALR), and apparently, back when this was a hot research topic, many people made this mistake.

According to some papers, NQLALR doesn't fit into the SLR -> LALR hierarchy, meaning, there are grammars that are SLR and not NQLALR. This observation can be used to debug an LALR implementation.

The following papers present example grammars that can be used to do that:

---

Simple Computation of LALR(1) Lookahead Sets, Manuel Bermudez

An LALR(1) grammar that is non-SLR(1) and non-NQLALR(1).

https://mdaines.github.io/grammophone/?s=UyAtPiBhIGcgZC4KUyAtPiBhIEEgYy4KUyAtPiBiIEEgZC4KUyAtPiBiIGcgYy4KQSAtPiBCLgpCIC0+IGcu#/

---

On the (non-) relationship between SLR(1) and NQLALR(1) grammars, Manuel E. Bermudez, Karl M. Schimpf

An SLR(1) grammar that is not NQLARL(1).

https://mdaines.github.io/grammophone/?s=SSAtPiBTLgpTIC0+IGEgQiBkLgpTIC0+IEMgQiBnLgpTIC0+IGMgZC4KQiAtPiBEIEUuCkQgLT4gLgpFIC0+IC4KQyAtPiBjLg==

[modulovalue]

Testcase: LALR correctness

The following paper discusses an incorrect oversimplification that one can make while implementing their algorithm.

Efficient Computation of LALR(1) Look-Ahead Sets, Frank DeRemer & Thomas Pennello

The paper doesn't discuss this, but I think, it is possible to look at the whole algorithm as a single dataflow problem. Their wording implies that two separate SCC runs are necessary. In any case, that grammar might also be valuable in verifying that an implementation is not incorrect in some obvious way.

According to the paper, the following grammar should be LALR(1) and an incorrect implementation would report it as not being LALR(1).

https://mdaines.github.io/grammophone/?s=UyAtPiBJLgpJIC0+IGEgQiBkLgpJIC0+IEMgQiBnLgpJIC0+IGMgZC4KQiAtPiBEIEUuCkMgLT4gYy4KRCAtPiAuCkUgLT4gLg==

[modulovalue]

Testcase: LALR(2)

The following paper discusses a grammar that is "almost" LALR(1). It has 9 inadequate states under LR(0). 8 of them can be resolved using LALR(1) and there's one left that needs LALR(2).

Practical Arbitrary Lookahead LR Parsing, Manuel E. Bermudez and Karl M. Schimpf

https://mdaines.github.io/grammophone/?s=UyAtPiBTICQuClMgLT4gQi4KQiAtPiBBRSBkZXEgQUUuCkIgLT4gU0UgdGVxIFNFLgoKQUUgLT4gQUUgcCBBVC4KQUUgLT4gQUUgbSBBVC4KQUUgLT4gQVQuCgpBVCAtPiBBVCBzIEFGLgpBVCAtPiBBRi4KCkFGIC0+IGlkLgoKU0UgLT4gU0UgcCBTVC4KU0UgLT4gU0UgbSBTVC4KU0UgLT4gU1QuCgpTVCAtPiBTVCBzIFNGLgpTVCAtPiBTRi4KClNGIC0+IGlkLg==

[modulovalue]

Metric: Includes Theorem

DeRemer & Pennello conjectured that if the "includes" relation of their LALR(1) construction algorithm contains a nontrivial SCC (... this misses the read condition, see the paper), then the grammar can't be LR(k) for any k. This was proven by A Short Proof of a Conjecture of DeRemer and Pennello
THOMAS J. SAGER. These are example grammars that Sager gives where that is the case:

G1:
https://mdaines.github.io/grammophone/?s=UyAtPiBCLgpBIC0+IGMgQy4KQSAtPiBhLgpCIC0+IGQgQS4KQyAtPiBiIEIuCkMgLT4gYiBkIEEgdC4=

G2:
https://mdaines.github.io/grammophone/?s=UyAtPiBCLgpBIC0+IGMgQy4KQSAtPiBhLgpCIC0+IGQgQSBELgpDIC0+IGIgZCBBIHQuCkMgLT4gYiBCLgpEIC0+IC4=

G3:
https://mdaines.github.io/grammophone/?s=UyAtPiBCLgpBIC0+IGMgQy4KQSAtPiBhLgpCIC0+IGQgQS4KQyAtPiBiIGQgQSBFIHQuCkMgLT4gYiBCLgpFIC0+IC4=

G4:
https://mdaines.github.io/grammophone/?s=UyAtPiBCLgpBIC0+IGMgQy4KQSAtPiBhLgpCIC0+IGQgQSBELgpDIC0+IGIgZCBBIEUgdC4KQyAtPiBiIEIuCkQgLT4gLgpFIC0+IC4=

In general, this property is undecidable. This is one of the few heuristics that are known for detecting whether a CFG is not LR(k) for any k.

[modulovalue]

Transformation: Recursion Scheme Fusion

The PhD Thesis by Philippe Charles on LALR(k) parsing and automatic error recovery discusses the following three grammars extensively (Figure 3.1, Page 31). They all model a simple BNF grammar. He uses them to highlight the importance of LALR(k) where k is > 1. ...

Example Grammar: LALR(2)

... (a) is LALR(2), (b) is a version of (a) that was converted to LALR(1) and (c) is a version of (a) that requires an explicit separator to be LALR(1) to maintain the shape of (a).

(a) (b) (c)

---

Note: this comment is very similar to this comment #26 (comment), the transformation from (a) to (b) appears to be the same.

[modulovalue]

Metric: Read Theorem

In Efficient Computation of LALR(1) Look-Ahead Sets, Frank DeRemer & Thomas Pennello, the authors prove that if there's a nontrivial SCC in the reads relation of their LALR(1) algorithm, then the grammar is not LR(k) for any k.

They give 2 grammars as examples. One is ambiguous, the other is not. This is the unambiguous grammar that is not LR(k) for any k. (The other ambiguous grammar is that one without the f at the end of the A production on grammophone.)