12.7 Anonymous Functions

Although functions are usually defined with defun and given
names at the same time, it is sometimes convenient to use an explicit
lambda expression—an anonymous function. Anonymous functions
are valid wherever function names are. They are often assigned as
variable values, or as arguments to functions; for instance, you might
pass one as the function argument to mapcar, which
applies that function to each element of a list (see Mapping Functions). See describe-symbols example, for a realistic example
of this.

When defining a lambda expression that is to be used as an anonymous
function, you can in principle use any method to construct the list.
But typically you should use the lambda macro, or the
function special form, or the #' read syntax:

In effect, this macro makes lambda forms “self-quoting”:
evaluating a form whose CAR is lambda yields the form
itself:

(lambda (x) (* x x))
⇒ (lambda (x) (* x x))

The lambda form has one other effect: it tells the Emacs
evaluator and byte-compiler that its argument is a function, by using
function as a subroutine (see below).

Special Form: functionfunction-object

This special form returns function-object without evaluating it.
In this, it is similar to quote (see Quoting). But unlike
quote, it also serves as a note to the Emacs evaluator and
byte-compiler that function-object is intended to be used as a
function. Assuming function-object is a valid lambda
expression, this has two effects:

When the code is byte-compiled, function-object is compiled into
a byte-code function object (see Byte Compilation).

When lexical binding is enabled, function-object is converted
into a closure. See Closures.

The read syntax #' is a short-hand for using function.
The following forms are all equivalent:

In the following example, we define a change-property
function that takes a function as its third argument, followed by a
double-property function that makes use of
change-property by passing it an anonymous function:

In that case, the anonymous function is kept as a lambda expression in
the compiled code. The byte-compiler cannot assume this list is a
function, even though it looks like one, since it does not know that
change-property intends to use it as a function.