
This indicates evaluation.
For example:
(+ 4 5) 9
This means that the result of
evaluating the form (+ 4 5) is 9.
If a form returns multiple values, those values might
be shown separated by spaces, line breaks, or commas.
For example:
(truncate 7 5)
1 2
(truncate 7 5)
1
2
(truncate 7 5)
1, 2
Each of the above three examples is equivalent, and specifies
that (truncate 7 5) returns two values, which are 1 and 2.
Some conforming implementations actually type an arrow (or some
other indicator) before showing return values, while others do not.
 OR
The notation "OR" is used to denote one of several possible
alternate results. The example
(charname #\a)
NIL
OR"LOWERCASEa"
OR"SmallA"
OR"LA01"
indicates that nil, "LOWERCASEa", "SmallA", "LA01" are
among the possible results of (charname #\a)  each with equal preference.
Unless explicitly specified otherwise, it should not be assumed that the set of possible
results shown is exhaustive.
Formally, the above example is equivalent to
(charname #\a) implementationdependent
but it is intended to provide additional information to illustrate some
of the ways in which it is permitted for implementations to diverge.
 NOT
The notation "NOT" is used to denote a result which is not possible.
This might be used, for example, in order to emphasize a situation where
some anticipated misconception might lead the reader to falsely believe
that the result might be possible. For example,
(functionlambdaexpression
(funcall #'(lambda (x) #'(lambda () x)) nil))
NIL, true, NIL
OR(LAMBDA () X), true, NIL
NOT NIL, false, NIL
NOT(LAMBDA () X), false, NIL
 ==
This indicates code equivalence. For example:
(gcd x (gcd y z)) ==(gcd (gcd x y) z)
This means that the results and observable sideeffects of evaluating
the form
(gcd x (gcd y z)) are always the same as the results
and observable sideeffects of
(gcd (gcd x y) z) for any
x, y, and z.

Common Lisp specifies input and output with respect to a noninteractive stream model.
The specific details of how interactive input and output are mapped onto that
noninteractive model are implementationdefined.
For example, conforming implementations are permitted to differ in issues
of how interactive input is terminated. For example, the function read
terminates when the final delimiter is typed on a noninteractive stream.
In some implementations, an interactive call to read returns
as soon as the final delimiter is typed, even if that delimiter is not a newline.
In other implementations, a final newline is always required.
In still other implementations, there might be a command which "activates"
a buffer full of input without the command itself being visible on the program's
input stream.
In the examples in this document, the notation "" precedes
lines where interactive input and output occurs. Within such a scenario,
"this notation" notates user input.
For example, the notation
(+ 1 (print (+ (sqrt (read)) (sqrt (read)))))
9 16
7
8
shows an interaction in which
"(+ 1 (print (+ (sqrt (read)) (sqrt (read)))))"
is a form to be evaluated,
"9 16 " is interactive input,
"7" is interactive output, and
"8" is the value yielded from the evaluation.
The use of this notation is intended to disguise small differences
in interactive input and output behavior between implementations.
Sometimes, the noninteractive stream model calls for a newline.
How that newline character is interactively entered is an
implementationdefined detail of the user interface, but in that
case, either the notation "<Newline>" or "[Return]" might be used.
(progn (format t "~&Who? ") (readline))
Who? Fred, Mary, and Sally[Return]
"Fred, Mary, and Sally", false