| [ < ] | [ > ] | [ << ] | [Plus haut] | [ >> ] | [Top] | [Table des matières] | [Index] | [ ? ] |
Defining functions is only half the battle. Functions don't do anything until you call them, i.e., tell them to run. Calling a function is also known as invocation.
The most common way of invoking a function is by evaluating a list. For
example, evaluating the list (concat "a" "b") calls the function
concat with arguments "a" and "b". Voir la section Evaluation,
for a description of evaluation.
When you write a list as an expression in your program, you specify which
function to call, and how many arguments to give it, in the text of the
program. Usually that's just what you want. Occasionally you need to
compute at run time which function to call. To do that, use the function
funcall. When you also need to determine at run time how many
arguments to pass, use apply.
funcall calls function with arguments, and returns
whatever function returns.
Since funcall is a function, all of its arguments, including
function, are evaluated before funcall is called. This means
that you can use any expression to obtain the function to be called. It
also means that funcall does not see the expressions you write for
the arguments, only their values. These values are not
evaluated a second time in the act of calling function; the operation
of funcall is like the normal procedure for calling a function, once
its arguments have already been evaluated.
The argument function must be either a Lisp function or a primitive
function. Special forms and macros are not allowed, because they make sense
only when given the “unevaluated” argument expressions. funcall
cannot provide these because, as we saw above, it never knows them in the
first place.
(setq f 'list)
⇒ list
(funcall f 'x 'y 'z)
⇒ (x y z)
(funcall f 'x 'y '(z))
⇒ (x y (z))
(funcall 'and t nil)
error--> Invalid function: #<subr and>
|
Compare these examples with the examples of apply.
apply calls function with arguments, just like
funcall but with one difference: the last of arguments is a
list of objects, which are passed to function as separate arguments,
rather than a single list. We say that apply spreads this list
so that each individual element becomes an argument.
apply returns the result of calling function. As with
funcall, function must either be a Lisp function or a primitive
function; special forms and macros do not make sense in apply.
(setq f 'list)
⇒ list
(apply f 'x 'y 'z)
error--> Wrong type argument: listp, z
(apply '+ 1 2 '(3 4))
⇒ 10
(apply '+ '(1 2 3 4))
⇒ 10
(apply 'append '((a b c) nil (x y z) nil))
⇒ (a b c x y z)
|
For an interesting example of using apply, see Definition of mapcar.
It is common for Lisp functions to accept functions as arguments or find
them in data structures (especially in hook variables and property lists)
and call them using funcall or apply. Functions that accept
function arguments are often called functionals.
Sometimes, when you call a functional, it is useful to supply a no-op function as the argument. Here are two different kinds of no-op function:
This function returns arg and has no side effects.
This function ignores any arguments and returns nil.
| [ < ] | [ > ] | [ << ] | [Plus haut] | [ >> ] | [Top] | [Table des matières] | [Index] | [ ? ] |
Ce document a été généré par Eric Reinbold le 13 Octobre 2007 en utilisant texi2html 1.78.