Is there any way to either handle or avoid left-recursion?

[amw-zero]

Hello. One feature that I just tried to add to a language I'm working on is function / method chaining, e.g.

something.call1().call2().call3() 

From my understanding, this requires left-recursion in the grammar because something.call1() must be parsed and become the receiver of call2(). And also from my understanding, and confirmed by an error I receive when trying to add a rule for this scenario, this isn't something that pest can handle.

I've read that left-recursion is something that PEG itself can't handle. Somewhat confusingly, there's a series of posts about how Python uses PEG for its grammar, and how they are able to get left-recursion to work with it, but it seems like they have their own custom PEG parser-generator implementation.

So, first, is it true that left-recursion just isn't possible with pest? And if not, is there some other way of achieving the method chaining syntax above?

[danaugrs]

The following might help: https://en.wikipedia.org/wiki/Left_recursion#Removing_left_recursion

Here's an example of basic left-recursion removal in Pest:

WHITESPACE = _{ " " | "\t" | "\r" }
int = @{ ASCII_DIGIT+ }
ident = @{ ASCII_ALPHA ~ ASCII_ALPHANUMERIC* }

// Original root rule with left recursion
// root = { root ~ "+" ~ root | ident | int }

// Same rule with left recursion removed
root = { (ident | int) ~ "+" ~ root | ident | int }

Here's another example for a more complex grammar, using this algorithm.

WHITESPACE = _{ " " | "\t" | "\r" }
int = @{ ASCII_DIGIT+ }
ident = @{ ASCII_ALPHA ~ ASCII_ALPHANUMERIC* }

add = {"+"}
mul = {"*"}

// Original root rule with left recursion
// expr = { expr ~ add ~ expr | expr ~ mul ~ expr | ident | int }

// Without left recursion
expr = { ident ~ exprPrime | int ~ exprPrime | exprPrime }
exprPrime = { (add ~ expr ~ exprPrime | mul ~ expr ~ exprPrime)? }

// Another way to write it
expr2 = { (ident|int)? ~ exprPrime2 }
exprPrime2 = { ((add|mul) ~ expr2 ~ exprPrime2)? }