12.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 Emacs Lisp and for other
function-like objects.

function

In Emacs 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.

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 we implement a function as a primitive is either
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 E.5 Writing Emacs Primitives.

lambda expression

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

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 10. 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 section 13. Macros, for how to define and
use macros.

command

A command is an object that command-execute can invoke; it
is a possible definition for a key sequence. Some functions are
commands; a function written in Lisp is a command if it contains an
interactive declaration (see section 21.2 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.
See section 21.1 Command Loop 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.

This function returns t if object is a byte-code
function. For example:

(byte-code-function-p (symbol-function 'next-line))
=> t

Function:subr-aritysubr

This function provides information about the argument list of a
primitive, subr. The returned value is a pair
(min . max). min is the minimum number of
args. max is the maximum number or the symbol many, for a
function with &rest arguments, or the symbol unevalled if
subr is a special form.