_C_l_a_s_s _M_e_t_h_o_d_s
	
	     UseMethod (name)
	     NextMethod(name, object, ...)
	     methods(generic.function, class)
	
	_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.
	
	     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 function
	     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 produces a suit-
	     able function, the function fun.default is used.
	
	     The function class prints the vector of names of
	     classes which an object inherits from.  Correspond-
	     ingly, class<- sets the classes which an object inher-
	     its from.  unclass returns (a copy of) its argument
	     with its class information removed.
	
	     is.object returns TRUE if its argument has a class
	     attribute and FALSE otherwise.  inherits indicates
	     whether its first argument inherits from a class with
	     name equal to its second argument.
	
	     methods can be used to find out about the methods for a
	     particular generic function or class.  See the examples
	     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 dif-
	     ferently!) 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)
	     cat("methods(print):\n")
	     print(methods(print))
	     cat("methods(class = data.frame):\n")
	     print(methods(class = data.frame))