gnu.org (original) (raw)

13.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 should use the lambda macro, or thefunction special form, or the #' read syntax:

Macro: lambda args [doc] [interactive] body…

This macro returns an anonymous function with argument listargs, documentation string doc (if any), interactive specinteractive (if any), and body forms given by body.

For example, this macro makes lambda forms almost self-quoting: evaluating a form whose CAR is lambda yields a value that is almost like the form itself:

(lambda (x) (* x x)) ⇒ #f(lambda (x) :dynbind (* x x))

When evaluating under lexical binding the result is a similar closure object, where the :dynbind marker is replaced by the captured variables (see Closures).

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

Special Form: function function-object

This special form returns the function value of the function-object. In many ways, it is similar to quote (see Quoting). But unlikequote, 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 function-object is a symbol and the code is byte compiled, the byte-compiler will warn if that function is not defined or might not be known at run time.

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

(lambda (x) (* x x)) (function (lambda (x) (* x x))) #'(lambda (x) (* x x))

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

(defun change-property (symbol prop function) (let ((value (get symbol prop))) (put symbol prop (funcall function value))))

(defun double-property (symbol prop) (change-property symbol prop (lambda (x) (* 2 x))))

Note that we do not quote the lambda form.

If you compile the above code, the anonymous function is also compiled. This would not happen if, say, you had constructed the anonymous function by quoting it as a list:

(defun double-property (symbol prop) (change-property symbol prop '(lambda (x) (* 2 x))))

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 thatchange-property intends to use it as a function.