Search code examples
ooprr-s3r-s4

is.object and the S3 class system

Using the class function allows us to determine the class of an object:

> x = 5
> class(x)
[1] "numeric"

I also understand that we can use the is.object command to determine if an object has a class. However some object types are implicit, that is

> is.object(x)
[1] FALSE

Would it be correct to state that all variables in R are objects and is.object is a test for non-implicit classes only?

Also, how do types fit into this. Naively, I thought that the following piece of code would produce an error:

> x = 5
> class(x) = "fake"
> x = X + 1
> x + 1
[1] 6
attr(,"class")
[1] "fake"

But x still has type "double", still everything still works. Can types be thought of as a superclass that all other objects inherit from?

Solution

  • typeof returns the type of internal C representation, and it is not used for method dispatch. So strictly speaking you can not think of types as "superclasses".

    There are instead basic classes (numeric, character, list, function etc) which roughly correspond to the names returned by typeof, but not always (for example type double is of class numeric, special and closure are of class function, and class data.frame is of type list!).

    With S3 and S4 systems you can build non trivial classes using basic classes (but not necessary extending one of those!! example: setClass("foo", list(a="numeric",b="character") does not extend any of the basic classes).

    For objects from these basic classes is.object returns FALSE. As its documentation says, this function provides a very fast way to check if the object is of user build S3 or S4 class (i.e. not one of basic classes).

    After casting x as "fake" your object is formally not of "numeric" class:

    is(x, "numeric")
#FALSE

    but it is interpretable as basic "numeric" object:

    is.numeric(x)
#TRUE

    And this is why + works here. So, internally, as @Richie already said the default method interprets x as of numeric basic class.

    This conceptual mess is because of S3 informal treatment of classes. Use S4 instead.

    correspondence between typeof(.) and basic class(.):

                                  typeof(.)  class(.)
NULL                          "NULL"     "NULL"
1                             "double"   "numeric"
1:1                           "integer"  "integer"
1i                            "complex"  "complex"
list(1)                       "list"     "list"
data.frame(x=1)               "list"     "data.frame"
pairlist(pi)                  "pairlist" "pairlist"
c                             "special"  "function"
lm                            "closure"  "function"
formals(lm)[[1]]              "symbol"   "name"
formals(lm)[[2]]              "symbol"   "name"
y~x                           "language" "formula"
expression((1))[[1]]          "language" "("
(y~x)[[1]]                    "symbol"   "name"
expression(x <- pi)[[1]][[1]] "symbol"   "name"