Leonardo,
I had a similar problem when I tried to implement reasonable behaviour for
logical operators for classes .bit and .bitwhich in package 'bit'.
Part of your problem is that R refuses to dispatch to any of two incompatible
classes and instead falls back to a meaningless default.
In theory, *this* problem *should* be solved in S3 by having a common
super-class 'foobar' for class(foo) <- c('foo','foobar') and class(bar) <-
c('bar','foobar'), but again, R does refuses to dispatch on the common
super-class (it directly tries to dispatch on the most special subclasses it
finds and does not check for a common class in the class hierarchy).
However, it appears that by having a common sub-class 'foobar' for class(foo)
<- c('foobar','foo') and class(bar) <- c('foobar','bar') we can get a common
dispatch and hence get control. I plan for my next release of package 'bit' a
common subclass 'booltype' to which R can dispatch without conflict. If you can
convince the author of 'foo' to use class(foo) <- c('foobar','foo') and base
his dispatch on 'foo', then you can dispatch on 'foobar' with no conflict and
use NextMethod to invoke his code for the foo-foo case, and your code for the
other cases. If the author refuses for some reason, you can still provide a
wrapper to convert class 'foo' into class c('foobar','foo'), or do more nasty
things like patching his class generator, but at least you don't need to patch
his methods!
I admit, using a physical subclass as a logical superclass is ugly: instead of
declaring 'apples' and 'oranges' as special cases of 'fruits', we tell R that
'a fruit is an apple' and that 'a fruit is an orange', such that R dispatches
to fruit-code for any combination of apples and oranges. Well ... the good
thing is that NextMethod can invoke the original apple-code or orange-code, and
we only need to write apple-orange-code and orange-apple-code to handle the new
combinations.
@R-devel: any comments or suggestions?
HTH
Jens Oehlschlägel
P.S. Example code and output follows
# If we try to have 'foo' and 'bar' as specializations of of a superclass
'foobar'
f <- "fooobj"
oldClass(f) <- c('foo','foobar')
"+.foo" <- function(e1,e2){
paste(e1,'+foo+',e2)
}
b <- "barobj"
oldClass(b) <- c('bar','foobar')
"+.bar" <- function(e1,e2){
paste(e1,'+bar+',e2)
}
"+.foobar" <- function(e1,e2){
if (inherits(e1,"foo") && inherits(e2,"bar"))
paste(e1,'+foobar+',e2)
else if (inherits(e1,"bar") && inherits(e2,"foo"))
paste(e1,'+barfoo+',e2)
else stop("should not be invoked for foo+foo or bar+bar (but it does)")
}
# Yes, this works
f + f
b + b
# but here R does not even dispatch on the common superclass 'foobar'
f + b
b + f
# However, it seems that we can trick R to do the right thing pretending that
'foobar' is a subclass of both, 'foo' and 'bar'
oldClass(f) <- c('foobar','foo')
"+.foo" <- function(e1,e2){
paste(e1,'+foo+',e2)
}
b <- "barobj"
oldClass(b) <- c('foobar','bar')
"+.bar" <- function(e1,e2){
paste(e1,'+bar+',e2)
}
"+.foobar" <- function(e1,e2){
if (inherits(e1,"foo") && inherits(e2,"bar"))
paste(e1,'+foobar+',e2)
else if (inherits(e1,"bar") && inherits(e2,"foo"))
paste(e1,'+barfoo+',e2)
else NextMethod(e1,e2) # make sure we dispatch to foo+foo and bar+bar
}
# This works
f + f
b + b
# but R does not even dispatch on the common ground 'foobar'
f + b
b + f
> # If we try to have 'foo' and 'bar' as specializations of of a superclass
> 'foobar'
>
> f <- "fooobj"
> oldClass(f) <- c('foo','foobar')
> "+.foo" <- function(e1,e2){
+ paste(e1,'+foo+',e2)
+ }
>
> b <- "barobj"
> oldClass(b) <- c('bar','foobar')
> "+.bar" <- function(e1,e2){
+ paste(e1,'+bar+',e2)
+ }
>
> "+.foobar" <- function(e1,e2){
+ if (inherits(e1,"foo") && inherits(e2,"bar"))
+ paste(e1,'+foobar+',e2)
+ else if (inherits(e1,"bar") && inherits(e2,"foo"))
+ paste(e1,'+barfoo+',e2)
+ else stop("should not be invoked for foo+foo or bar+bar (but it does)")
+ }
>
> # Yes, this works
> f + f
[1] "fooobj +foo+ fooobj"
> b + b
[1] "barobj +bar+ barobj"
> # but here R does not even dispatch on the common superclass 'foobar'
> f + b
Fehler in f + b : nicht-numerisches Argument für binären Operator
Zusätzlich: Warnmeldung:
Inkompatible Methoden ("+.foo", "+.bar") für "+"
> b + f
Fehler in b + f : nicht-numerisches Argument für binären Operator
Zusätzlich: Warnmeldung:
Inkompatible Methoden ("+.bar", "+.foo") für "+"
>
>
> # However, it seems that we can trick R to do the right thing pretending that
> 'foobar' is a subclass of both, 'foo' and 'bar'
>
> oldClass(f) <- c('foobar','foo')
> "+.foo" <- function(e1,e2){
+ paste(e1,'+foo+',e2)
+ }
>
> b <- "barobj"
> oldClass(b) <- c('foobar','bar')
> "+.bar" <- function(e1,e2){
+ paste(e1,'+bar+',e2)
+ }
>
> "+.foobar" <- function(e1,e2){
+ if (inherits(e1,"foo") && inherits(e2,"bar"))
+ paste(e1,'+foobar+',e2)
+ else if (inherits(e1,"bar") && inherits(e2,"foo"))
+ paste(e1,'+barfoo+',e2)
+ else NextMethod(e1,e2) # make sure we dispatch to foo+foo and bar+bar
+ }
>
> # This works
> f + f
[1] "fooobj +foo+ fooobj"
> b + b
[1] "barobj +bar+ barobj"
> # but R does not even dispatch on the common ground 'foobar'
> f + b
[1] "fooobj +foobar+ barobj"
> b + f
[1] "barobj +barfoo+ fooobj"
Gesendet: Donnerstag, 16. Februar 2017 um 17:52 Uhr
Von: "Leonardo Silvestri" <[email protected]>
An: [email protected]
Betreff: [R-pkg-devel] Is a double dispatch possible with two S3 classes?
Hello,
I have stumbled upon an S3 class dispatch issue which is easily solved
using S4 classes, but I'd like to know if there is a way to solve it
without changing the type of class used.
The problem is as follows. There is an S3 class 'foo' which is defined
in a package over which I don't have control. Then there is an S3 class
'bar' derived from 'foo' in a package that can be modified.
Here is some code for 'foo':
as.foo <- function(x) {
oldClass(x) <- "foo"
x
}
print.foo <- function(x, ...) print(paste(x, "foo"))
"-.foo" <- function(e1, e2) "-.foo was called"
And here is some code for 'bar':
as.bar <- function(x) {
oldClass(x) <- c("bar", "foo")
x
}
print.bar <- function(x, ...) print(paste(x, "bar"))
Now the '-' operator must be defined in such a way that the behaviour is
different depending on the operand classes, and in particular
'bar'-'bar' needs to be different from 'bar'-'foo'. If I define the
following function:
"-.bar" <- function(e1, e2) "-.bar was called"
then I get the following results.
as.foo(1) - as.foo(2) # uses '-.foo'
as.bar(1) - as.bar(2) # uses '-.bar'
as.bar(1) - as.foo(2) # uses '-.default' and issues
# Incompatible methods warning
as.foo(1) - as.bar(2) # uses '-.default' and issues
# Incompatible methods warning
So that seems like a dead end.
If, overcoming an instinctive shudder of disgust, I redefine '-.foo' in
the "bar" package, I have checked that correctness is at the mercy of
the order of loading of the packages, even though the "bar" package
imports the "foo" package. So that doesn't seem to work either.
Before committing to making 'bar' an S4 class, does anyone know if there
is another option that would allow 'bar' to remain an S3 class?
Thanks,
Leo
______________________________________________
[email protected] mailing list
https://stat.ethz.ch/mailman/listinfo/r-package-devel
______________________________________________
[email protected] mailing list
https://stat.ethz.ch/mailman/listinfo/r-package-devel
