A rule is called em(recursive) when its em(result) nonterminal appears also on
its right hand side. Nearly all b() grammars need to use recursion,
because that is the only way to define a sequence of any number of
somethings. Consider this recursive definition of a comma-separated sequence
of one or more expressions:
        verb(
    expseq1:  
            expseq1 ',' exp
    | 
            exp
    ;
        )
    Since the recursive use of expseq1 is the leftmost symbol in the right
hand side, we call this em(left recursion). By contrast, here the same
construct is defined using em(right recursion):
        verb(
    expseq1:  
            exp ',' expseq1
    | 
            exp
    ;
        )
    Any kind of sequence can be defined using either left recursion or right
recursion, but you should always use left recursion, because it can parse a
sequence of any number of elements with bounded stack space. Right recursion
uses up space on the b() stack in proportion to the number of elements in the
sequence, because all the elements must be shifted onto the stack before the
rule can be applied even once. See chapter ref(ALGORITHM) for further
explanation of this.

em(Indirect) or em(mutual) recursion occurs when the result of the rule does
not appear directly on its right hand side, but does appear in rules for other
nonterminals which do appear on its right hand side. For example:
        verb(
    expr:     
        primary '+' primary
    |
        primary
        ;

    primary:  
        constant
    | 
        '(' expr ')'
    ;
        )
    defines two mutually-recursive nonterminals, since each refers to the
other.

