| % File src/library/methods/man/implicitGeneric.Rd |
| % Part of the R package, https://www.R-project.org |
| % Copyright 1995-2007 R Core Team |
| % Distributed under GPL 2 or later |
| |
| \name{implicitGeneric} |
| \alias{implicitGeneric} |
| \alias{setGenericImplicit} |
| \alias{prohibitGeneric} |
| \alias{registerImplicitGenerics} |
| \alias{implicit generic} |
| \title{Manage Implicit Versions of Generic Functions} |
| \description{ |
| The implicit generic mechanism stores generic versions of |
| functions |
| in a table in a package. The package does not want the current |
| version of the function to be a generic, however, and retains the |
| non-generic version. |
| |
| When a call to \code{\link{setMethod}} or |
| \code{\link{setGeneric}} creates a generic version for one of these |
| functions, the object in the table is used. |
| This mechanism is only needed if special arguments were used to |
| create the generic; e.g., the \code{signature} or the \code{valueClass} |
| options. |
| |
| Function \code{implicitGeneric()} returns the implicit |
| generic version, \code{setGenericImplicit()} turns a generic implicit, |
| \code{prohibitGeneric()} prevents your function from being made |
| generic, and \code{registerImplicitGenerics()} saves a set of implicit |
| generic definitions in the cached table of the current session. |
| } |
| \usage{ |
| implicitGeneric(name, where, generic) |
| setGenericImplicit(name, where, restore = TRUE) |
| prohibitGeneric(name, where) |
| registerImplicitGenerics(what, where) |
| } |
| |
| \arguments{ |
| \item{name}{ Character string name of the function.} |
| \item{where}{ Package or environment in which to register the implicit |
| generics. When using the functions from the top level of your own |
| package source, this argument should be omitted.} |
| \item{generic}{ Obsolete, and likely to be deprecated.} |
| \item{restore}{Should the non-generic version of the function be |
| restored?.} |
| \item{what}{Optional table of |
| the implicit generics to register, but nearly always omitted, when |
| it defaults to a standard metadata name.} |
| } |
| \details{ |
| |
| Multiple packages may define methods for the same function, to apply |
| to classes defined in that package. Arithmetic and other operators, |
| \code{plot()} and many other basic computations are typical |
| examples. It's essential that all such packages write methods for |
| the \emph{same} definition of the generic function. So long as that |
| generic uses the default choice for signature and other parameters, |
| nothing needs to be done. |
| |
| If the generic has special properties, these need to be ensured for |
| all packages creating methods for it. The simplest solution is just |
| to make the function generic in the package that originally owned |
| it. If for some reason the owner(s) of that package are unwilling |
| to do this, the alternative is to define the correct generic, |
| save it in a special table and restore the non-generic version by |
| calling \code{setGenericImplicit}. |
| |
| |
| Note that the package containing the function can define methods for the implicit generic as |
| well; when the implicit generic is made a real generic, those methods |
| will be included. |
| |
| The usual reason for having a |
| non-default implicit generic is to provide a non-default signature, |
| and the usual reason for \emph{that} is to allow lazy evaluation of |
| some arguments. All arguments in the signature of a |
| generic function must be evaluated at the time the function needs to |
| select a method. |
| In the base function \code{with()} in the example below, evaluation of the argument |
| \code{expr} must be delayed; therefore, it is excluded from the signature. |
| |
| If you want to completely prohibit anyone from turning your function |
| into a generic, call \code{prohibitGeneric()}. |
| |
| Function \code{implicitGeneric()} returns the implicit generic |
| version of the named function. If there is no table of these or if |
| this function is not in the table, the result of a simple call |
| \code{setGeneric(name)} is returned. |
| } |
| |
| \section{Implicit Generics for Base Functions}{ |
| Implicit generic versions exist for some functions in the packages |
| supplied in the distribution of \R itself. These are stored in the |
| \sQuote{methods} package itself and will always be available. |
| |
| As emphasized repeatedly in the documentation, |
| \code{\link{setGeneric}()} calls for a function in another package |
| should never have non-default settings for arguments such as |
| \code{signature}. |
| The reasoning applies specially to functions in supplied packages, |
| since methods for these are likely to exist in multiple packages. |
| A call to \code{implicitGeneric()} will show the generic version. |
| } |
| |
| \value{ |
| Function \code{implicitGeneric()} returns the implicit generic |
| definition (and caches that definition the first time if it has to |
| construct it). |
| |
| The other functions exist for their side effect and return nothing |
| useful. |
| } |
| |
| \seealso{\code{\link{setGeneric}}} |
| \examples{ |
| |
| ### How we would make the function with() into a generic: |
| |
| ## Since the second argument, 'expr' is used literally, we want |
| ## with() to only have "data" in the signature. |
| |
| \dontrun{ |
| setGeneric("with", signature = "data") |
| ## Now we could predefine methods for "with" if we wanted to. |
| |
| ## When ready, we store the generic as implicit, and restore the |
| original |
| |
| setGenericImplicit("with") |
| } |
| |
| implicitGeneric("with") |
| |
| # (This implicit generic is stored in the 'methods' package.) |
| } |
| \keyword{programming} |
| \keyword{methods} |