allow more permissive rules about racket-peg HOT 9 CLOSED

I understand the problem.. it is hard to analyse a rule when a rule is defined in terms of things in another file.

Thinking about cost: "amount of code to implement feature" vs "value of feature".

• The code to implement this feature would be very complex and affect many parts of the system.
• The value of the feature is low, because it just gives a warning on some bad grammars which is good. But often the programmer will understand the problem when running it infinite loops. So it makes life easier but only a small amount.

So I think we should do without this feature. But It was good to raise it and consider it!

from racket-peg.

Yeah, Good idea to detect left recursion and nullable star.

transforming into a non-left recursive grammar sounds very complex and I think we should not do this! It will be enough to give an error.

from racket-peg.

https://github.com/PhilippeSigaud/Pegged/wiki/Left-Recursion

To detect left-recursive rules, direct or indirect, we need to calculate the NULL set and the left relation.

NULL = {A | A is a non-terminal and (peg A "") suceeds}

left(A,B) <=> there exist some rule A < B C or A <- B C or A <-- B C where B is a non-terminal and C is whatever. Another alternative is that A <- B C, B is elem of NULL, and the production A <- C allow to derive some left relation.

Each ordered choice contribute to this sets in this way : A <- B / C / D , if NULL(B) and NULL(C) and NULL(D), then NULL(A)

left(A,B) can be infered by A <- C / D if left(A,B) can be infered by A <- C or A <- D

from racket-peg.

I am testing the algorithm above and see a problem : we can't see if some peg imported is nullable.

(Require a);
B <- A B / 'b';

I can't see if the A above is nullable and without that I can't tell if B can be left recursive or not.

from racket-peg.

WIth require, what we import is peg-rule:A but with the function alone, can't see if there's some input that match and dont consume anything.

from racket-peg.

I dont want to get something that was decided before, but with import we can intercept the require, and before that, open the file, transform in peg, and do something about

#lang peg
//A.rkt

A <- 'a'? ;

#lang peg
//B.rkt

import A.rkt;
B <- A B / 'b' ;

We can, instead of transform in a require immediately, open the file, transform in rules, using (peg peg ...) and execute the algorithm above with all the peg, even if that is modularized.

from racket-peg.

Can you see a different solution?

from racket-peg.

This means that I can close that?

from racket-peg.

yeah

from racket-peg.