\HeaderA{showMethods}{Show all the methods for the specified function(s)}{showMethods}
\keyword{methods}{showMethods}
\begin{Description}\relax
Show a summary of the methods for one or more generic functions,
possibly restricted to those involving specified classes.
\end{Description}
\begin{Usage}
\begin{verbatim}
showMethods(f = character(), where = topenv(parent.frame()),
            classes = NULL, includeDefs = FALSE, inherited = TRUE,
            showEmpty = TRUE, printTo = stdout())
\end{verbatim}
\end{Usage}
\begin{Arguments}
\begin{ldescription}
\item[\code{f}] one or more function names.  If omitted, all functions
will be examined. 
\item[\code{where}] If \code{where} is supplied, the methods definition from
that position will be used; otherwise, the current definition is
used (which will include inherited methods that have arisen so far
in the session). If \code{f} is omitted, \code{where} controls
where to look for generic functions.
\item[\code{classes}] If argument \code{classes} is supplied, it is a vector
of class names that restricts the displayed results to those methods
whose signatures include one or more of those classes. 
\item[\code{includeDefs}] If \code{includeDefs} is \code{TRUE}, include the
definitions of the individual methods in the printout. 
\item[\code{inherited}] If \code{inherits} is \code{TRUE}, then methods that
have been found by inheritance, so far in the session, will be
included and marked as inherited. Note that an inherited method
will not usually appear until it has been used in this session.
See \code{\LinkA{selectMethod}{selectMethod}} if you want to know what method is
dispatched for particular classes of arguments.
\item[\code{showEmpty}] logical indicating if methods with empty method lists
should be shown at all.  Note
that \code{FALSE} is \emph{not yet implemented}.
\item[\code{printTo}] The connection on which the printed information will be
written.  If \code{printTo} is \code{FALSE}, the output will be
collected as a character vector and returned as the value of the
call to \code{showMethod}.   See \code{\LinkA{show}{show}}.

\end{ldescription}
\end{Arguments}
\begin{Details}\relax
The output style is different from S-Plus in that it does not show the
database from which the definition comes, but can optionally include
the method definitions.
\end{Details}
\begin{Value}
If \code{printTo} is \code{FALSE}, the character vector that would
have been printed is returned; otherwise the value is the connection
or filename.
\end{Value}
\begin{References}\relax
The R package \pkg{methods} implements, with a few exceptions, the
programming interface for classes and methods in the book
\emph{Programming with Data} (John M. Chambers, Springer, 1998), in
particular sections 1.6, 2.7, 2.8, and chapters 7 and 8.

While the programming interface for the \pkg{methods} package follows
the reference, the R software is an original implementation, so
details in the reference that reflect the S4 implementation may appear
differently in R.  Also, there are extensions to the programming
interface developed more recently than the reference.  For a
discussion of details and ongoing development, see the web page
\url{http://developer.r-project.org/methodsPackage.html} and the
pointers from that page.
\end{References}
\begin{SeeAlso}\relax
\code{\LinkA{setMethod}{setMethod}}, and \code{\LinkA{GenericFunctions}{GenericFunctions}}
for other tools involving methods;
\code{\LinkA{selectMethod}{selectMethod}} will show you the method dispatched for a
particular function and signature of classes for the arguments.
\end{SeeAlso}
\begin{Examples}
\begin{ExampleCode}

## Assuming the methods for plot
## are set up as in the example of help(setMethod),
## print (without definitions) the methods that involve class "track":
showMethods("plot", classes = "track")
## Not run: 
Function "plot":
x = ANY, y = track
x = track, y = missing
x = track, y = ANY
## End(Not run)

## Show all methods from the same place that a class is defined:
not.there <- !any("package:stats4" == search())
if(not.there) library(stats4)
showMethods(class = "mle")                           # not really helpful
showMethods(class = "mle", where = "package:stats4") # much better
if(not.there) detach("package:stats4")
\end{ExampleCode}
\end{Examples}

