# How to write a grammar for LL(1) parsing

LL(1) is left-to-right with one look-ahead. We must write a grammar that uses the first token to decide which rule to use and once it is committed, there is no turning back.

Let us begin with a simple binary operation. The input is similar to the following sentence.

`table1 = 10 and (table2 = 20 or table3 = 30)`

Its grammar will be:

```clause := clause and clause clause := clause or clause clause := name = value clause := ( clause )```

To have the operator cascaded `( A and B and C ...)`, we use  right recursion (on the rule "clauses").

```clause := expr clauses clauses := logic expr clauses | empty logic := and | or```

(Note to the reader: is it left or right association?)
Let the precedence of "=" be higher than "and" "or". So, first, we "embed" the operator "=" rule "inside" by creating a new rule for it (the rule "expr").

`expr := name = value`

Finally to take care of the highest precedence "(...)" we embed it in the innest rule.

`expr := name = value | ( clause )`

The next rule we will consider is the grammar for a list (containing variable number of elements).  This is the example of a list.

`(10, 20, 30)`

```list := ( element ) element := number elements elements := , number elements | empty```

Please note that this grammar does not allow an empty list` ()`. It can be incorporated into the grammar easily.

```list := ( member member := ) | number members members := , number members ) | empty ```
end