The R Project SVN – R – Diff – /trunk/src/library/methods/man/NextMethod.Rd



    Calling with no arguments is often the natural way to use
    \code{callNextMethod}; see the examples.
    }
}
\details{
  The \sQuote{next} method (i.e., the first inherited method) is defined
  to be that method which \emph{would} have been called if the current
  method did not exist. This is more-or-less literally what happens: The
  current method (to be precise, the method with signature given by the
  \code{defined} slot of the method from which \code{callNextMethod} is
  called) is deleted from a copy of the methods for the current generic,

  The statement that the method is called with the current arguments is
  more precisely as follows.  Arguments that were missing in the current
  call are still missing (remember that \code{"missing"} is a valid
  class in a method signature).  For a formal argument, say \code{x}, that
  appears in the original call, there is a corresponding argument in the
  next method call equivalent to \code{x = x}.  In effect, this
  means that the next method sees the same actual arguments, but
  arguments are evaluated only once.
}
\value{
  The value returned by the selected method.

The R Project SVN R

(root)/trunk/src/library/methods/man/NextMethod.Rd @ 28362 – Rev 42333 → 42963

Rev 42333		Rev 42963
Line 29...		Line 29...
29	`Calling with no arguments is often the natural way to use`	29	`Calling with no arguments is often the natural way to use`
30	`\code{callNextMethod}; see the examples.`	30	`\code{callNextMethod}; see the examples.`
31	`}`	31	`}`
32	`}`	32	`}`
33	`\details{`	33	`\details{`
34	`The \dQuote{next} method (i.e., the first inherited method) is defined`	34	`The \sQuote{next} method (i.e., the first inherited method) is defined`
35	`to be that method which \emph{would} have been called if the current`	35	`to be that method which \emph{would} have been called if the current`
36	`method did not exist. This is more-or-less literally what happens: The`	36	`method did not exist. This is more-or-less literally what happens: The`
37	`current method (to be precise, the method with signature given by the`	37	`current method (to be precise, the method with signature given by the`
38	`\code{defined} slot of the method from which \code{callNextMethod} is`	38	`\code{defined} slot of the method from which \code{callNextMethod} is`
39	`called) is deleted from a copy of the methods for the current generic,`	39	`called) is deleted from a copy of the methods for the current generic,`
Line 65...		Line 65...
65	`The statement that the method is called with the current arguments is`	65	`The statement that the method is called with the current arguments is`
66	`more precisely as follows. Arguments that were missing in the current`	66	`more precisely as follows. Arguments that were missing in the current`
67	`call are still missing (remember that \code{"missing"} is a valid`	67	`call are still missing (remember that \code{"missing"} is a valid`
68	`class in a method signature). For a formal argument, say \code{x}, that`	68	`class in a method signature). For a formal argument, say \code{x}, that`
69	`appears in the original call, there is a corresponding argument in the`	69	`appears in the original call, there is a corresponding argument in the`
70	`next method call equivalent to \dQuote{\code{x = x}}. In effect, this`	70	`next method call equivalent to \code{x = x}. In effect, this`
71	`means that the next method sees the same actual arguments, but`	71	`means that the next method sees the same actual arguments, but`
72	`arguments are evaluated only once.`	72	`arguments are evaluated only once.`
73	`}`	73	`}`
74	`\value{`	74	`\value{`
75	`The value returned by the selected method.`	75	`The value returned by the selected method.`