

   CCllaassss MMeetthhooddss

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

   DDeessccrriippttiioonn::

        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 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.

   NNoottee::

        The `methods' function was written by Martin Maechler.

   SSeeee AAllssoo::

        `class'

   EExxaammpplleess::

        methods(summary)

        methods(print)

        methods(class = data.frame)

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

