Here is a simple language that we can use to understand associativity.

    L = { a, a+a, a+a+a, a+a+a+a, ... }


-----------------------------------------------------------------------------


1.) Here is an EBNF grammar for this language.


EBNF:    expr -> a ( '+' a )*


Using this grammar, how might you parse the string "a+a+a+a"?
It doesn't seem that you can.


-----------------------------------------------------------------------------


2.) Here is an ambiguous BNF grammar for this language.


BNF:    expr -> expr '+' expr | a


Using this grammar you can parse the string "a+a+a+a" numerous ways.


-----------------------------------------------------------------------------


3.) Here is an unambiguous, "right associative", BNF grammar
(and two EBNF grammars derived from it).


BNF:    expr -> a '+' expr | a


EBNF:   expr -> a [ '+' expr ]   (notice that this is right recursive)

EBNF:   expr -> a ( '+' a )*     (we removed (or "eliminated") the recursion)


Using this BNF grammar you parse the string "a+a+a+a" as if it were
"grouped" as a+(a+(a+a))


-----------------------------------------------------------------------------


4.) Here is an unambiguous, "left associative", BNF grammar
(and two EBNF grammars derived from it).


BNF:    expr ->  expr '+' a | a


EBNF:   expr -> [ expr '+' ] a  (notice that this is left recursive)

EBNF:   expr -> ( a '+' )* a    (we removed (or "eliminated") the recursion)


Using this BNF grammar you parse the string "a+a+a+a" as if it were
"grouped" as ((a+a)+a)+a


Notice from the last two BNF grammars that, in essence, left associative
means you have a (left recursive) grammar production that captures the
"big stuff" on the left side of an operator and it captures a "little thing"
on the right side of the operator, e.g.,
       expr -> expr '+' a
and right associative means you have a (right recursive) grammar production
that captures the "big stuff" on the right side of an operator and a
"little thing" on the left side of the operator, e.g.,
       expr -> a '+' expr


Also notice that the grammars that use the Kleene star don't tell you
how you should parse a string.

-----------------------------------------------------------------------------


Let us look at how the recursion is removed from the previous BNF grammar.

Here is a left-most derivation of a sequence of sentential forms from
the BNF grammar.

                     expr
               expr + a
           expr + a + a
       expr + a + a + a
   expr + a + a + a + a
      a + a + a + a + a

Notice how the "expression part" is growing on its left hand side, and in
each step it grows by concatenating the string "a +". So that means we can
think of growing a string in the language by starting with the sting "a"
and then concatenating on the left as many "a+" strings as we like. Hence,
the description [a'+']*a, which uses iteration (the Kleene star) in place
of recursion.


Question: What does the following EBNF give you?

EBNF:   expr -> ( expr '+' )* a