

methods {base}                               R Documentation

_C_l_a_s_s _M_e_t_h_o_d_s

_D_e_s_c_r_i_p_t_i_o_n_:

     R possesses a simple generic function mechanism which
     can be used for an object-oriented style of program-
     ming.  Method despatch takes place based on the class
     of the first argument to the generic function or on the
     object supplied as an argument to `UseMethod' or
     `NextMethod'.

_U_s_a_g_e_:

     UseMethod(generic, object )
     NextMethod(generic, object, ...)
     methods(generic.function, class)

_D_e_t_a_i_l_s_:

     An R ``object'' is a data object which has a `class'
     attribute.  A class attribute is a vector of character
     strings giving the names of the classes which the
     object ``inherits'' from.  When a generic function
     `fun' is applied to an object with class attribute
     `c("first", "second")', the system searches for a func-
     tion called `fun.first' and, if it finds it, applied it
     to the object.  If no such function is found a function
     called `fun.second' is tried.  If no class name pro-
     duces a suitable function, the function `fun.default'
     is used.

     `methods' can be used to find out about the methods for
     a particular generic function or class.  See the exam-
     ples below for details.

     Now for some obscure details that need to appear some-
     where.  These comments will be slightly different than
     those in Appendix A of the White S Book. `UseMethod'
     creates a ``new'' function call with arguments matched
     as they came in to the generic.  Any local variables
     defined before the call to `UseMethod' are retained
     (!?).  Any statements after the call to `UseMethod'
     will not be evaluated as `UseMethod' does not return.

     `NextMethod' invokes the next method (determined by the
     class).  It does this by creating a special call frame
     for that method.  The arguments will be the same in
     number, order and name as those to the current method
     but their values will be promises to evaluate their
     name in the current method and environment.  Any argu-
     ments matched to `...' are handled specially.  They are
     passed on as the promise that was supplied as an argu-
     ment to the current environment. (S does this differ-
     ently!)  If they have been evaluated in the current (or
     a previous environment) they remain evaluated.

_N_o_t_e_:

     The `methods' function was written by Martin Maechler.

_S_e_e _A_l_s_o_:

     `class'

_E_x_a_m_p_l_e_s_:

     methods(summary)

     methods(print)

     methods(class = data.frame)

     methods("[")#- does not list the C-internal ones...

