Hoje imagino que os steps do LR parser serão desta maneira:
| Action | Stack | Remaining |
|---|---|---|
| Shift | ( |
λx.λy.x y) z |
| Shift | (λ |
x.λy.x y) z |
| Shift | (λx |
.λy.x y) z |
| Shift | (λx. |
λy.x y) z |
| Shift | (λx.λ |
y.x y) z |
| Shift | (λx.λy |
.x y) z |
| Shift | (λx.λy. |
x y) z |
| Shift | (λx.λy.x |
y) z |
| Reduce | (λx.λy.<Var x> |
y) z |
| Reduce | (λx.<Abs y (Var x)> |
y) z |
| Reduce | (<Abs x (Abs y (Var x))> |
y) z |
| Shift | (<Abs x (Abs y (Var x))> |
y) z |
| Shift | (<Abs x (Abs y (Var x))> y |
) z |
| Reduce | (<Abs x (Abs y (Var x))> <Var y> |
) z |
| Reduce | (<App (Abs x (Abs y (Var x))) (Var y)> |
) z |
| Shift | (<App (Abs x (Abs y (Var x))) (Var y)>) |
z |
| Reduce | <App (Abs x (Abs y (Var x))) (Var y)> |
z |
| Shift | <App (Abs x (Abs y (Var x))) (Var y)> |
z |
| Reduce | <(App (Abs x (Abs y (Var x))) (Var y))> <Var z> |
|
| Reduce | <App (App (Abs x (Abs y (Var x))) (Var y)) (Var z)> |
O que ainda está confuso para mim é os detalhes da implementação, como eu faria para determinar a ordem de precedencia dessas expressões?
Cheguei a pesquisar um pouco e vi que teria que fazer um parser de precedência de operadores (um LR parser com lookahead de 1, ou LR(1)) pelo que entendi, mas não tenho certeza. https://en.wikipedia.org/wiki/Operator-precedence_parser
Não tenho certeza como fazer um parser desses, me pergunto o que ele faria em casos como (λx.λy.x, se existiria lookahead até achar y ou ), reduziria o y primeiro antes de reduzir a Application (<Var x> <Var y>) e etc.