17.1 What Is a Function?

In a general sense, a function is a rule for carrying on a computation given several values called arguments. The result of the computation is called the value of the function. The computation can also have side effects: lasting changes in the values of variables or the contents of data structures.

Here are important terms for functions in SXEmacs Lisp and for other function-like objects.

function

In SXEmacs Lisp, a function is anything that can be applied to arguments in a Lisp program. In some cases, we use it more specifically to mean a function written in Lisp. Special forms and macros are not functions.

command

A command is a possible definition for a key sequence—we count mouse events and menu accesses as key sequences for this purpose. More formally, within SXEmacs lisp, a command is something that command-execute can invoke.

Some functions are commands; a function written in Lisp is a command if it contains an interactive declaration. A trivial interactive declaration is a line (interactive) immediately after the documentation string. For more complex examples, with prompting and completion, see See Defining Commands. Such a function can be called from Lisp expressions like other functions; in this case, the fact that the function is a command makes no difference.

Keyboard macros (strings and vectors) are commands also, even though they are not functions. A symbol is a command if its function definition is a command; such symbols can be invoked with M-x. The symbol is a function as well if the definition is a function.

In the case where you want to call a command in reaction to a user-generated event, you'll need to bind it to that event. For how to do this, see See Key Binding Commands. See Command Overview.

keystroke command

A keystroke command is a command that is bound to a key sequence (typically one to three keystrokes). The distinction is made here merely to avoid confusion with the meaning of “command” in non-Emacs editors; for Lisp programs, the distinction is normally unimportant.

primitive

A primitive is a function callable from Lisp that is written in C, such as car or append. These functions are also called built-in functions or subrs. (Special forms are also considered primitives.)

Usually the reason that a function is a primitives is because it is fundamental, because it provides a low-level interface to operating system services, or because it needs to run fast. Primitives can be modified or added only by changing the C sources and recompiling the editor. See Writing Lisp Primitives.

lambda expression

A lambda expression is a function written in Lisp. These are described in the following section.

special form

A special form is a primitive that is like a function but does not evaluate all of its arguments in the usual way. It may evaluate only some of the arguments, or may evaluate them in an unusual order, or several times. Many special forms are described in Control Structures.

macro

A macro is a construct defined in Lisp by the programmer. It differs from a function in that it translates a Lisp expression that you write into an equivalent expression to be evaluated instead of the original expression. Macros enable Lisp programmers to do the sorts of things that special forms can do. See Macros, for how to define and use macros.

compiled function

A compiled function is a function that has been compiled by the byte compiler. See Compiled-Function Type.