The bug should now be fixed. The actual change is very small, but it
enforces a semantic definition that may be relevant, so we should
discuss it.
The question is: what method does callNextMethod() refer to? The
definition now enforced is: the "next method" is the method found for
the defining signature (the signature in the call to setMethod()) if
that method itself was absent. See the Details section of the
documentation for callNextMethod in the latest development version.
In previous versions, it was possible to use callNextMethod() to get at
different inherited methods, depending on the instance, that is on the
class of the particular object(s) in the call, while going through the
_same_ method containing the callNextMethod().
I think the current semantics is cleaner and more appropriate to a
functional style of programming. It is also needed if the dispatch of
the next method were to be "compiled in" to the method in a future
version (which should, in fact, be easy to do).
But watch for uses of callNextMethod() that now behave differently.
Seth Falcon wrote:
>Hi,
>
>Given a simple three class hierarchy: A <-- B <-- C
>
>I want to define an initialize method for each class such that when I
>call new("C", x=5), the initialize methods for A and B are used to
>incrementally build the object.
>
>When I do what seems obvious to me using callNextMethod, I get an
>infinite recursion. An example follows...
>
>setClass("A", representation(a="numeric"))
>setClass("B", representation(b="numeric"), contains="A")
>setClass("C", representation(c="numeric"), contains="B")
>
>setMethod("initialize", signature(.Object="A"),
> function(.Object, x) {
> cat("in A\n")
> [EMAIL PROTECTED] <- x
> .Object
> })
>
>setMethod("initialize", signature(.Object="B"),
> function(.Object, x) {
> cat("in B\n")
> .Object <- callNextMethod(.Object=.Object, x=x)
> [EMAIL PROTECTED] <- [EMAIL PROTECTED] + 1
> .Object
> })
>
>setMethod("initialize", signature(.Object="C"),
> function(.Object, x) {
> cat("in C\n")
> .Object <- callNextMethod(.Object=.Object, x=x)
> [EMAIL PROTECTED] <- [EMAIL PROTECTED] + [EMAIL PROTECTED] + 1
> .Object
> })
>
>
>## Works as I am expecting for B
>
>
>>myB <- new("B", 4)
>>
>>
>in B
>in A
>
>## When you create a C, the B method gets called but the appropriate
>## next method info seems lost and we end up back in C's method ?!
>
>
>>myC <- new("C", 5)
>>
>>
>in C
>in B
>in C
>in B
>in C
> C-c C-c
>
>Should this work? Is there a better way to organize the initializers
>for a simple hierarchy (perhaps assume that args to the initializers
>are not the same for A, B, and C).
>
>Thanks,
>
>+ seth
>
>______________________________________________
>R-devel@r-project.org mailing list
>https://stat.ethz.ch/mailman/listinfo/r-devel
>
>
>
[[alternative HTML version deleted]]
______________________________________________
R-devel@r-project.org mailing list
https://stat.ethz.ch/mailman/listinfo/r-devel
