GNU Info

Info Node: (elisp)Anonymous Functions

(elisp)Anonymous Functions


Next: Function Cells Prev: Mapping Functions Up: Functions
Enter node , (file) or (file)node

Anonymous Functions
===================

   In Lisp, a function is a list that starts with `lambda', a byte-code
function compiled from such a list, or alternatively a primitive
subr-object; names are "extra".  Although usually functions are defined
with `defun' and given names at the same time, it is occasionally more
concise to use an explicit lambda expression--an anonymous function.
Such a list is valid wherever a function name is.

   Any method of creating such a list makes a valid function.  Even
this:

     (setq silly (append (lambda (x)) (list (list '+ (* 3 4) 'x))))
     => (lambda (x) (+ 12 x))

This computes a list that looks like `(lambda (x) (+ 12 x))' and makes
it the value (_not_ the function definition!) of `silly'.

   Here is how we might call this function:

     (funcall silly 1)
     => 13

(It does _not_ work to write `(silly 1)', because this function is not
the _function definition_ of `silly'.  We have not given `silly' any
function definition, just a value as a variable.)

   Most of the time, anonymous functions are constants that appear in
your program.  For example, you might want to pass one as an argument to
the function `mapcar', which applies any given function to each element
of a list.

   Here we define a function `change-property' which uses a function as
its third argument:

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

Here we define a function that uses `change-property', passing it a
function to double a number:

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

In such cases, we usually use the special form `function' instead of
simple quotation to quote the anonymous function, like this:

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

   Using `function' instead of `quote' makes a difference if you
compile the function `double-property'.  For example, if you compile
the second definition of `double-property', the anonymous function is
compiled as well.  By contrast, if you compile the first definition
which uses ordinary `quote', the argument passed to `change-property'
is the precise list shown:

     (lambda (x) (* x 2))

The Lisp compiler cannot assume this list is a function, even though it
looks like one, since it does not know what `change-property' will do
with the list.  Perhaps it will check whether the CAR of the third
element is the symbol `*'!  Using `function' tells the compiler it is
safe to go ahead and compile the constant function.

   We sometimes write `function' instead of `quote' when quoting the
name of a function, but this usage is just a sort of comment:

     (function SYMBOL) == (quote SYMBOL) == 'SYMBOL

   The read syntax `#'' is a short-hand for using `function'.  For
example,

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

is equivalent to

     (function (lambda (x) (* x x)))

 - Special Form: function function-object
     This special form returns FUNCTION-OBJECT without evaluating it.
     In this, it is equivalent to `quote'.  However, it serves as a
     note to the Emacs Lisp compiler that FUNCTION-OBJECT is intended
     to be used only as a function, and therefore can safely be
     compiled.  Contrast this with `quote', in Note: Quoting.

   See `documentation' in Note: Accessing Documentation, for a
realistic example using `function' and an anonymous function.


automatically generated by info2www version 1.2.2.9