This section describes how individual tokens
(identifiers, numbers, etc.) are formed from sequences of characters.
The following sections describe how expressions and programs are formed
from sequences of tokens.

<Intertoken space> may occur on either side of any token, but not
within a token.

Tokens which require implicit termination (identifiers, numbers,
characters, and dot) may be terminated by any <delimiter>, but not
necessarily by anything else.

The following rules for <num R>, <complex R>, <real
R>, <ureal R>, <uinteger R>, and <prefix R>
should be replicated for R = 2, 8, 10,
and 16. There are no rules for <decimal 2>, <decimal
8>, and <decimal 16>, which means that numbers containing
decimal points or exponents must be in decimal radix.

The following grammar for quasiquote expressions is not context-free.
It is presented as a recipe for generating an infinite number of
production rules. Imagine a copy of the following rules for
D = 1, 2, 3, .... D keeps track of the nesting depth.

In <quasiquotation>s, a <list template D> can sometimes be
confused with either an <unquotation D> or a
<splicing unquotation D>. The interpretation as an
<unquotation> or <splicing unquotation D> takes precedence.

This section gives rewrite rules for the derived expression types. By
the application of these rules, any expression can be reduced to a
semantically equivalent expression in which only the primitive
expression types (literal, variable, call, lambda, if,
set!) occur.

where <temp 1>, <temp 2>, ... are variables, distinct
from <variable 1>, ..., that do not free occur in the
original <init> expressions, and <undefined> is an expression
which returns something that when stored in a location makes it an
error to try to obtain the value stored in the location. (No such
expression is defined, but one is assumed to exist for the purposes of this
rewrite rule.) The second let expression in the expansion is not
strictly necessary, but it serves to preserve the property that the
<init> expressions are evaluated in an arbitrary order.

(begin <sequence>)
== ((lambda () <sequence>))

The following alternative expansion for begin does not make use
of the ability to write more than one expression in the body of a lambda
expression. In any case, note that these rules apply only if
<sequence> contains no definitions.

The following expansion for do is simplified by the assumption
that no <step> is omitted. Any do expression in which a
<step> is omitted can be replaced by an equivalent do
expression in which the corresponding <variable> appears as
the <step>.