{\page \name={Upgrade to Latte 2.0}

Latte 2.0 contains two changes incompatible with earlier versions.
If you've used earlier versions of Latte, you may need to make the

The changes involve the way user-defined functions are computed.  In
earlier versions, the result of invoking a user-defined function was
an implicitly constructed group containing the values of all of the
body's subexpressions.  Example:

{\example
\{\\def \{\\foo \\x\}
The value of x is \\x\}}

Invoking this as {\tt \{\\foo 17\}} produced a group containing {\tt
The}, {\tt value}, {\tt of}, {\tt x}, {\tt is}, and {\tt 17}.

The new behavior is for user-defined functions to evaluate all
subexpressions but return only the {\em last one}.  So the example
function {\code \\foo}, above, produces only {\tt 17} with the new
version of Latte.

{\h3 The first change}

Functions like this can be restored to their correct behavior by
enclosing the body of the function with an extra pair of braces, like
so:

{\example
\{\\def \{\\foo \\x\}
\{The value of x is \\x\}\}}

Now the last subexpression of {\tt \\foo} is the {\em only}
subexpression and contains all of the desired text.

{\b Note:} it should not be necessary to change the way these
functions are {\em used}, only the way they are {\em defined}.

{\h3 The second change}

The bodies of {\tt \\let} expressions are treated the same way as the
bodies of function definitions.  So in a {\tt \\let} expression like
this:

{\example
\{\\let \{\{\\x 17\}\}
The value of x is \\x\}}

older versions of Latte would produce

{\example The value of x is 17}

but Latte 2.0 produces only {\tt 17} (the last subexpression of the
body).  To preserve the old behavior, wrap the body in a pair of
braces:

{\example
\{\\let \{\{\\x 17\}\}
\{The value of x is \\x\}\}}

{\h3 Why did we make this change?}

The behavior of pre-2.0 versions of Latte introduced an ambiguity in
certain functions, ones that sometimes returned a group and sometimes
returned some other kind of value.  Other code wishing to call such
functions could never be sure whether the group being returned was
actually the desired return value or merely {\em contained} the
desired return value.  As a result, it was very difficult to write
Latte code that dealt with structured data, such as groups containing
groups.

The new behavior eliminates this ambiguity, and makes it possible to
write functions not all of whose subexpressions are contained in the
result (something that is often desirable).  It also corresponds more
closely to the behavior of other similar languages.

In order to help detect user-defined functions and {\tt \\let}
expressions that probably need to be adjusted, we've invented a new
kind of error called "useless subexpression."  When you invoke a
function or {\tt \\let} expression that contains subexpressions that
are not part of the return value and that have no other effects (such
as setting variables or calling other functions), Latte now signals a
"useless subexpression" error.  So a function definition like the
first {\tt \\foo}, above, would signal a useless subexpression''
error as soon as the subexpression {\tt The} is reached---it's not
part of the return value, and it doesn't have any other effects.}