\section{Concepts}


\begin{Type}{IDENTIFIER}
Identifiers in REDUCE consist of one or more alphanumeric characters, of
which the first must be alphabetical.  The maximum number of characters
allowed is system dependent, but is usually over 100.  However, printing
is simplified if they are kept under 25 characters.

You can also use special characters in your identifiers, but each must be
preceded by an exclamation point \name{!} as an escape character.  Useful
special characters are \name{\ # \$ \% ^ \& * - + = ? < > ~ | / !} and
the space.  Note that the use of the exclamation point as a special
character requires a second exclamation point as an escape character.
The underscore \name{\_} is special in this regard.  It must be preceded
by an escape character in the first position in an identifier, but is
treated like a normal letter within an identifier.

Other characters, such as \name{( ) # ; ` ' "} can also be used if
preceded by a \name{!}, but as they have special meanings to the Lisp
reader it is best to avoid them to avoid confusion.

Many system identifiers have * before or after their names, or - between
words.  If you accidentally pick one of these names for your own identifier,
it could have disastrous effects.  For this reason it is wise not to include
* or - anywhere in your identifiers.

You will notice that REDUCE does not use the escape characters when it prints
identifiers containing special characters; however, you still must use them 
when you refer to these identifiers.  Be careful when editing statements
containing escaped special characters to treat the character and its escape
as an inseparable pair.

Identifiers are used for variable names, labels for \name{go to} statements,
and names of arrays, matrices, operators, and procedures.  Once an identifier is
used as a matrix, array, scalar or operator identifier, it may not be used 
again as a matrix, array or operator.  An operator or array identifier may 
later be used as a scalar without problems, but a matrix identifier cannot be 
used as a scalar.  All procedures are entered into the system as operators, so 
the name of a procedure may not be used as a matrix, array, or operator 
identifier either.   
 
\end{Type}


\begin{Type}{KERNEL}
A \name{kernel} is a form that cannot be modified further by the REDUCE
canonical simplifier.  Scalar variables are always kernels.  The
other important class of kernels are operators with their arguments.
Some examples should help clarify this concept:
\begin{TEX}
  \begin{center}
  \begin{tabular}{|l@{\hspace*{2cm}}|l|}
    \hline
    \multicolumn{1}{|c|}{Expression} & \multicolumn{1}{c|}{Kernel?}\\
    \hline
          \verb|x|                    &          Yes\\
          \meta{varname}               &         Yes\\
          \verb|cos(a)|                &        Yes\\
          \verb|log(sin(x**2))|          &       Yes\\
          \verb|a*b|                      &      No\\
          \verb|(x+y)**4|                  &     No\\
          \meta{matrix identifier}          &    No\\
     \hline
  \end{tabular}
  \end{center}
\end{TEX}
\begin{INFO}
{
\begin{verbatim}
        Expression                     Kernel?

          x                              Yes
          varname                        Yes
          cos(a)                         Yes
          log(sin(x**2))                 Yes
          a*b                            No
          (x+y)**4                       No
          matrix-identifier              No
\end{verbatim}
}
\end{INFO}
Many REDUCE operators expect kernels among their arguments.  Error messages
result from attempts to use non-kernel expressions for these arguments.
 
\end{Type}


\begin{Type}{STRING}
A \name{string} is any collection of characters enclosed in double quotation
marks (\name{"}).  It may be used as an argument for a variety of commands
and operators, such as \name{in}, \name{rederr} and \name{write}.
\begin{Examples}
write "this is a string";    &      this is a string \\
write a, " ", b, " ",c,"!";  &      A B C!
\end{Examples}
\end{Type}


