Overloading methods in R

Ali -

Wed, Apr 20, 2005 10:45 AM

Thanks a lot Tony. I am trying to apply the overloading to the methods 
created by R.oo package and, unfortunately, R.oo uses S3-style classes; so I 
cannot use the features of S4 methods as you described. On the other hand, I 
caouldn't find a decent OO package which is based on S4 AND comes with the 
official release of R.

Assume we have this class created using R.oo:

-------------------------
require(R.oo)

setConstructorS3("SomeClass",
    function(...)
    {
        extend(Object(), "SomeClass");
    }
);

setMethodS3(
    "fun",
    "SomeClass",
    function(this, x, ...)
    {
        paste(x);
    }
);
-------------------------

Now if we overload the method by:

-------------------------
setMethodS3(
    "fun",
    "SomeClass",
    function(this, x, y, ...)
    {
        paste(x, y);
    }
);
-------------------------

then R.oo overwrites the method 'fun' with the new definition. As the 
overloaded methods share the same class, it is not possible to use the 
function overloading method as you described.

I hope there is some other way to handle this problem.

One thing to realize is that "methods" in R are very different to those in 
other common "object-oriented" languages such as C++, Java, or Python.  One 
difference is that methods are not intimately associated with a class 
definition -- the method dispatch system pulls disparate pieces of 
information together.  Another difference is that the choice of which 
method to invoke can depend on all arguments, not just the first.

Yet another thing to realize is that R has two class systems (commonly 
known as something like "S3" and "S4" methods and classes).  Each has its 
own way of defining classes, generic functions and methods.  The S4 class 
system offers more control over which method is called.  Consult the "Green 
Book" for details of the S4 system.  (See the FAQ for full details of the 
"Green Book").

Here's an example of something like what you are asking for, using the S4 
class system.  Note that this example doesn't involve the definition of any 
classes, just a generic and methods for some standard classes. Also note 
that a generic and its methods should have the same argument names.

setGeneric("foo", function(x,y) standardGeneric("foo"))

[1] "foo"

setMethod("foo", c("ANY", "missing"),

+     function(x,y) "x:any y:missing")
[1] "foo"

setMethod("foo", c("numeric", "numeric"),

+     function(x,y) "x:numeric y:numeric")
[1] "foo"

setMethod("foo", c("missing", "numeric"),

+     function(x,y) "x:missing y:numeric")
[1] "foo"

foo(1,2)

[1] "x:numeric y:numeric"

foo(1)

[1] "x:any y:missing"

foo(y=2)

[1] "x:missing y:numeric"

foo(y="bar")

Error in foo(y = "bar") : no direct or inherited method for function 'foo' 
for this call

(You can execute the above commands under Windows by copying the entire 
transcript to the clipboard, and then using the "Paste commands only" menu 
item under the "Edit" menu in the "R console" window.)

hope this helps to at least get you started,

Tony Plate

Overloading methods in R

Thread (25 messages)