The Lisp interpreter, or evaluator, is the part of Emacs that computes the value of an expression that is given to it. When a function written in Lisp is called, the evaluator computes the value of the function by evaluating the expressions in the function body. Thus, running any Lisp program really means running the Lisp interpreter.
A Lisp object that is intended for evaluation is called a form or expression1. The fact that forms are data objects and not merely text is one of the fundamental differences between Lisp-like languages and typical programming languages. Any object can be evaluated, but in practice only numbers, symbols, lists and strings are evaluated very often.
In subsequent sections, we will describe the details of what evaluation means for each kind of form.
It is very common to read a Lisp form and then evaluate the form,
but reading and evaluation are separate activities, and either can be
performed alone. Reading per se does not evaluate anything; it
converts the printed representation of a Lisp object to the object
itself. It is up to the caller of
read to specify whether this
object is a form to be evaluated, or serves some entirely different
purpose. See Input Functions.
Evaluation is a recursive process, and evaluating a form often
involves evaluating parts within that form. For instance, when you
evaluate a function call form such as
(car x), Emacs
first evaluates the argument (the subform
x). After evaluating
the argument, Emacs executes the function (
car), and if
the function is written in Lisp, execution works by evaluating the
body of the function (in this example, however,
not a Lisp function; it is a primitive function implemented in C).
See Functions, for more information about functions and function
Evaluation takes place in a context called the environment, which consists of the current values and bindings of all Lisp variables (see Variables).2 Whenever a form refers to a variable without creating a new binding for it, the variable evaluates to the value given by the current environment. Evaluating a form may also temporarily alter the environment by binding variables (see Local Variables).
Evaluating a form may also make changes that persist; these changes
are called side effects. An example of a form that produces a
side effect is
(setq foo 1).
Do not confuse evaluation with command key interpretation. The
editor command loop translates keyboard input into a command (an
interactively callable function) using the active keymaps, and then
call-interactively to execute that command. Executing the
command usually involves evaluation, if the command is written in
Lisp; however, this step is not considered a part of command key
interpretation. See Command Loop.