call                  package:base                  R Documentation

_F_u_n_c_t_i_o_n _C_a_l_l_s

_D_e_s_c_r_i_p_t_i_o_n:

     Create or test for objects of mode '"call"'.

_U_s_a_g_e:

     call(name, ...)
     is.call(x)
     as.call(x)

_A_r_g_u_m_e_n_t_s:

    name: a non-empty character string naming the function to be
          called.

     ...: arguments to be part of the call.

       x: an arbitrary R object.

_D_e_t_a_i_l_s:

     'call' returns an unevaluated function call, that is, an
     unevaluated expression which consists of the named function
     applied to the given arguments ('name' must be a quoted string
     which gives the name of a function to be called).  Note that
     although the call is unevaluated, the arguments '...' are
     evaluated.

     'call' is a primitive, so the first argument (named or not) is
     taken as 'name' and the remaining arguments as arguments for the
     constructed call: 'call(x="c", 1,3, name="foo")' is a call to 'c'
     and not to 'foo'.

     'is.call' is used to determine whether 'x' is a call (i.e., of
     mode '"call"').

     Objects of mode '"list"' can be coerced to mode '"call"'. The
     first element of the list becomes the function part of the call,
     so should be a function or the name of one (as a symbol; a quoted
     string will not do).  

     All three are primitive functions.

_R_e_f_e_r_e_n_c_e_s:

     Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988) _The New S
     Language_. Wadsworth & Brooks/Cole.

_S_e_e _A_l_s_o:

     'do.call' for calling a function by name and argument list;
     'Recall' for recursive calling of functions; further
     'is.language', 'expression', 'function'.

_E_x_a_m_p_l_e_s:

     is.call(call) #-> FALSE: Functions are NOT calls

     ## set up a function call to round with argument 10.5
     cl <- call("round", 10.5)
     is.call(cl)# TRUE
     cl
     ## such a call can also be evaluated.
     eval(cl)# [1] 10

     A <- 10.5
     call("round", A)        # round(10.5)
     call("round", quote(A)) # round(A)
     f <- "round"
     call(f, quote(A))       # round(A)
     ## if we want to supply a function we need to use as.call or similar
     f <- round
     ## Not run: call(f, quote(A))  # error: first arg must be character
     (g <- as.call(list(f, quote(A))))
     eval(g)
     ## alternatively but less transparently
     g <- list(f, quote(A))
     mode(g) <- "call"
     g
     eval(g)
     ## see also the examples in the help for do.call