Info Catalog elisp: Functions elisp: Lambda Expressions

elisp: What Is a Function

 
 12.1 What Is a Function?
 ========================
 
 In a general sense, a function is a rule for carrying out a computation
 given input values called “arguments”.  The result of the computation is
 called the “value” or “return value” of the function.  The computation
 can also have side effects, such as lasting changes in the values of
 variables or the contents of data structures.
 
    In most computer languages, every function has a name.  But in Lisp,
 a function in the strictest sense has no name: it is an object which can
 _optionally_ be associated with a symbol (e.g., ‘car’) that serves as
 the function name.  Function Names.  When a function has been
 given a name, we usually also refer to that symbol as a “function”
 (e.g., we refer to “the function ‘car’”).  In this manual, the
 distinction between a function name and the function object itself is
 usually unimportant, but we will take note wherever it is relevant.
 
    Certain function-like objects, called “special forms” and “macros”,
 also accept arguments to carry out computations.  However, as explained
 below, these are not considered functions in Emacs Lisp.
 
    Here are important terms for functions and function-like objects:
 
 “lambda expression”
      A function (in the strict sense, i.e., a function object) which is
      written in Lisp.  These are described in the following section.
      Lambda Expressions.
 
 “primitive”
      A function which is callable from Lisp but is actually written in
      C.  Primitives are also called “built-in functions”, or “subrs”.
      Examples include functions like ‘car’ and ‘append’.  In addition,
      all special forms (see below) are also considered primitives.
 
      Usually, a function is implemented as a primitive because it is a
      fundamental part of Lisp (e.g., ‘car’), or because it provides a
      low-level interface to operating system services, or because it
      needs to run fast.  Unlike functions defined in Lisp, primitives
      can be modified or added only by changing the C sources and
      recompiling Emacs.  See Writing Emacs Primitives.
 
 “special form”
      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.  Examples include ‘if’, ‘and’, and ‘while’.  Special
      Forms.
 
 “macro”
      A construct defined in Lisp, which differs from a function in that
      it translates a Lisp expression into another expression which is to
      be evaluated instead of the original expression.  Macros enable
      Lisp programmers to do the sorts of things that special forms can
      do.  Macros.
 
 “command”
      An object which can be invoked via the ‘command-execute’ primitive,
      usually due to the user typing in a key sequence “bound” to that
      command.  Interactive Call.  A command is usually a
      function; if the function is written in Lisp, it is made into a
      command by an ‘interactive’ form in the function definition (
      Defining Commands).  Commands that are functions can also be
      called from Lisp expressions, just like other functions.
 
      Keyboard macros (strings and vectors) are commands also, even
      though they are not functions.  Keyboard Macros.  We say
      that a symbol is a command if its function cell contains a command
      (Symbol Components); such a “named command” can be invoked
      with ‘M-x’.
 
 “closure”
      A function object that is much like a lambda expression, except
      that it also encloses an environment of lexical variable bindings.
      Closures.
 
 “byte-code function”
      A function that has been compiled by the byte compiler.  
      Byte-Code Type.
 
 “autoload object”
      A place-holder for a real function.  If the autoload object is
      called, Emacs loads the file containing the definition of the real
      function, and then calls the real function.  Autoload.
 
    You can use the function ‘functionp’ to test if an object is a
 function:
 
  -- Function: functionp object
      This function returns ‘t’ if OBJECT is any kind of function, i.e.,
      can be passed to ‘funcall’.  Note that ‘functionp’ returns ‘t’ for
      symbols that are function names, and returns ‘nil’ for special
      forms.
 
 Unlike ‘functionp’, the next three functions do _not_ treat a symbol as
 its function definition.
 
  -- Function: subrp object
      This function returns ‘t’ if OBJECT is a built-in function (i.e., a
      Lisp primitive).
 
           (subrp 'message)            ; ‘message’ is a symbol,
                ⇒ nil                 ;   not a subr object.
           (subrp (symbol-function 'message))
                ⇒ t
 
  -- Function: byte-code-function-p object
      This function returns ‘t’ if OBJECT is a byte-code function.  For
      example:
 
           (byte-code-function-p (symbol-function 'next-line))
                ⇒ t
 
  -- Function: subr-arity subr
      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.
 

Info Catalog elisp: Functions elisp: Lambda Expressions