eintr: Evaluating Inner Lists

 
 1.6.1 Evaluating Inner Lists
 ----------------------------
 
 If evaluation applies to a list that is inside another list, the outer
 list may use the value returned by the first evaluation as information
 when the outer list is evaluated.  This explains why inner expressions
 are evaluated first: the values they return are used by the outer
 expressions.
 
    We can investigate this process by evaluating another addition
 example.  Place your cursor after the following expression and type ‘C-x
 C-e’:
 
      (+ 2 (+ 3 3))
 
 The number 8 will appear in the echo area.
 
    What happens is that the Lisp interpreter first evaluates the inner
 expression, ‘(+ 3 3)’, for which the value 6 is returned; then it
 evaluates the outer expression as if it were written ‘(+ 2 6)’, which
 returns the value 8.  Since there are no more enclosing expressions to
 evaluate, the interpreter prints that value in the echo area.
 
    Now it is easy to understand the name of the command invoked by the
 keystrokes ‘C-x C-e’: the name is ‘eval-last-sexp’.  The letters ‘sexp’
 are an abbreviation for “symbolic expression”, and ‘eval’ is an
 abbreviation for “evaluate”.  The command evaluates the last symbolic
 expression.
 
    As an experiment, you can try evaluating the expression by putting
 the cursor at the beginning of the next line immediately following the
 expression, or inside the expression.
 
    Here is another copy of the expression:
 
      (+ 2 (+ 3 3))
 
 If you place the cursor at the beginning of the blank line that
 immediately follows the expression and type ‘C-x C-e’, you will still
 get the value 8 printed in the echo area.  Now try putting the cursor
 inside the expression.  If you put it right after the next to last
 parenthesis (so it appears to sit on top of the last parenthesis), you
 will get a 6 printed in the echo area!  This is because the command
 evaluates the expression ‘(+ 3 3)’.
 
    Now put the cursor immediately after a number.  Type ‘C-x C-e’ and
 you will get the number itself.  In Lisp, if you evaluate a number, you
 get the number itself—this is how numbers differ from symbols.  If you
 evaluate a list starting with a symbol like ‘+’, you will get a value
 returned that is the result of the computer carrying out the
 instructions in the function definition attached to that name.  If a
 symbol by itself is evaluated, something different happens, as we will
 see in the next section.