TITLE(methods @@ Class Methods)
USAGE(
UseMethod (name)
NextMethod(name, object, ...)
methods(generic.function, class)
)
ALIAS(UseMethod)
ALIAS(NextMethod)
ALIAS(methods)
DESCRIPTION(
R possesses a simple generic function mechanism
which can be used for an object-oriented style of programming.
Method despatch takes place based on the class of the first argument
to the generic function.
PARA
An R ``object'' is a data object which has a LANG(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 LANG(fun) is applied to an object 
with class attribute c("first","second"), the system searches
for a function called LANG(fun.first) and, if it finds it,
applied it to the object.  If no such function is found
a function called LANG(fun.second) is tried.
If no class name produces a suitable function, the function
LANG(fun.default) is used.
PARA
The function LANG(class) prints the vector of names of classes
which an object inherits from.
Correspondingly, LANG(class<-) sets the classes
which an object inherits from.
LANG(unclass) returns (a copy of) its argument
with its class information removed.
PARA
LANG(inherits) indicates whether its first argument inherits
from a class with name equal to its second argument.
PARA
LANG(methods) can be used to find out about the methods
for a particular generic function or class.
See the examples below for details.
PARA
Now for some obscure details that need to appear somewhere. 
These comments will be slightly different than those in Appendix A of
the White S Book. LANG(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 LANG(UseMethod) will
not be evaluated as LANG(UseMethod) does not return.
PARA
LANG(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 arguments matched to LANG(...) are handled
specially. They are passed on as the promise that was supplied as an
argument to the current environment. (S does this differently!) If they
have been evaluated in the current (or a previous environment) they
remain evaluated.
)
NOTE(
The LANG(methods) function was written by Martin Maechler.
)
SEEALSO(
LANG(LINK(class))
)
EXAMPLES(
methods(summary)

cat("methods(print):\n")
print(methods(print))

cat("methods(class = data.frame):\n")
print(methods(class = data.frame))
)
