R and Objects

A full discussion of object-oriented programming -- while admittedly one of the most powerful paradigms in modern computing -- is probably better suited to an environment where the primary focus is on learning about computer science, as opposed to statistics. As such, we will not attempt to describe working with objects in R in all its full glory. However, having at least a minimal understanding of objects can help us understand why we see some of the things we see in R.

R uses two different (competing) structures for objects, one referred to as S3 and the other as S4. The S3 structure is simpler than S4, and at the heart of many familiar R actions. In these notes, we will focus solely on the S3 structure.

Before discussing exactly what an object is, let us first talk about generic functions. You may have noticed that many of the functions you use in R do different things when presented with different types of input. For example, consider the summary() function:

> v = c(1,2,6,5,7,3,4,5)
> summary(v)
   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
  1.000   2.750   4.500   4.125   5.250   7.000 

> t = as.table(matrix(c(51,43,22,92,28,21,68,22,9),ncol=3,byrow=TRUE))
> summary(t)
Number of cases in table: 356 
Number of factors: 2 
Test for independence of all factors:
    Chisq = 18.51, df = 4, p-value = 0.0009808

Here, we see summary() does one thing for vectors and something different for tables.

The print() function behaves in a similar way -- doing different things for different types of input:

> print(v)
[1] 1 2 6 5 7 3 4 5

> print(t)
   A  B  C
A 51 43 22
B 92 28 21
C 68 22  9

Functions in R like these, whose behavior depends on the types of their inputs, are called generic functions.

Now suppose that you wanted to write an R program to run simulations on a number of card games. Given that each card has a suit and rank, it would be nice if we could consolidate both pieces of information into something that could be stored in a single variable. Of course, R provides the list data type that serves that purpose well.

Assuming that the ranks of cards in order was given by {Ace, 2, 3, ..., 10, Jack, Queen, King} and the suits of cards in order was given by {Hearts, Clubs, Diamonds, Spades}, you might start with something like this:

> my.card = list(rank=11,suit=3)  # a possible way to represent the Jack of Diamonds

However, when we print my.card, the result is similar to what one would see when printing any other list:

> print(my.card)
$rank
[1] 11

$suit
[1] 3

Wouldn't it be better if -- when dealing with cards, anyways -- R could show us something more descriptive, like "Jack of Diamonds"?

If we register this list as being associated with a particular class of card objects which we will name as "card", then we can supply a custom implementation of print() that is just used for objects of the "card" class, as shown below:

> my.card = list(rank=11,suit=3)
> class(my.card) = "card"          # <-- this "registers" my.card as 
                                   #     an object of class "card"

Now all we need to do is provide a custom implementation for printing cards. As mentioned before, the print() function is an existing generic function. It knows to check the class name of whatever object it is given and then take an appropriate action based on the class it sees. The function print() takes this action by essentially dispatching its work to another function.

For example, if executing print(x) and x is a table, then the print() function would ask the function named print.table() to do the work. If x is a card, print() will instead look for a function named print.card() to do its work.

The print.table() function is one of the many functions already built into R, but the print.card() function we will need to provide:

print.card = function(c) {
  suit.names = c("hearts","clubs","diamonds","spades")
  rank.names = c("ace",paste(2:10),"jack","queen","king")
  cat(rank.names[c$rank],"of",suit.names[c$suit],"\n")
}

Now, look what happens when we try to print my.card:

> print(my.card)
jack of diamonds 

That looks better!

Additional card objects we might create will be printed in the same way -- just remember that each such creation involves populating a list with the information associated with the card and registering the list with the class "card"

> another.card = list(rank=1,suit=4)
> class(another.card) = "card"
> print(another.card)
ace of spades 

To simplify the creation of objects, a common approach is to write another function (called a constructor) to attend to these two tasks, such as the one below for cards:

card = function(r,s) {
  c = list(rank=r,suit=s)
  class(c) = "card"
  return(c)
}

# now we can use the constructor above 
# to create multiple card objects...

> c1 = card(1,4)
> print(c1)
ace of spades 
 
> c2 = card(2,1)
> print(c2)
l2 of hearts 

Now would be a good time to note that the generic print() method is unique in that it gets called automatically when evaluating a variable by itself. To see this consider the following, which produces outputs identical to the last two outputs above:

> c1 = card(1,4)
> c1
ace of spades 

> c2 = card(2,1)
> c2
2 of hearts

Beyond just print(), there are other built-in generic functions for which one can provide custom implementations associated with different classes. We've already mentioned the summary() function. The plot() function too is generic.

Certainly though, the makers of R were not able to predict all of the function names that people would ever want to be generic. This suggests a natural question: "How does one make a function generic?"

Let us make things more concrete. Suppose in creating code to run simulations of a number of card games you not only create a "card" class, but you also create a "winnings" class. Perhaps objects associated with this latter class include the various amounts won from a variety of different games.

In some games, different cards have different "values". For example, suppose in the game Crazy Face, face cards are worth 10 points, while other cards are worth points equal to their rank. That said, there is a total "value" associated with all of one's winnings too.

Wouldn't it be great if we had a generic function value() that we could associate with both the card and winnings classes, so that value(x) would produce the appropriate output for the nature of the input it was given? In other words, we desire value() to be a generic function.

We can make value() generic with the following:

value = function(obj) {
  UseMethod("value")
}

After executing the above, we can supply the associated custom implementations. For example, we could add the following implementation for objects associated with the card class:

value.card = function(c) {
  return(ifelse(c$rank <= 10, c$rank, 10))
}

Here's an example of its use:

> drawn.card = card(13,2)
> drawn.card
king of clubs 

> value(drawn.card)   # note, a king is a face card
                      # and our value.card() function
                      # assigns face cards the value 10  
[1] 10

If one is curious about which classes are associated with a given generic function, one can use the methods() function.

As an example, the print() function, as you might expect, is associated with many other classes, as suggested by what follows:

> methods(print)
  [1] print.acf*                                          
  [2] print.anova*                                        
  [3] print.aov*                                          
  [4] print.aovlist*                                      
  [5] print.ar*                                           
  [6] print.Arima*                                        
  [7] print.arima0*                                       
  [8] print.AsIs                                          
  [9] print.aspell*                                       
 [10] print.aspell_inspect_context*                       
 [11] print.bibentry*                                     
 [12] print.Bibtex*                                       
 [13] print.browseVignettes*                              
 [14] print.by                                            
 [15] print.card                                          
 [16] print.changedFiles*                                 
 [17] print.check_code_usage_in_package*                  
 [18] print.check_compiled_code*                          
 [19] print.check_demo_index*                             
 [20] print.check_depdef* 
 ...

While all are not shown above, there are a total of 184 built-in classes associated with print(). Of course, we have just added the card class, so it shows up in this list as well. (see [15] above).

(If you are wondering why some of these are asterisked, this happens when they are hidden under other namespaces. We won't talk about namespaces here, but you can always google "R namespaces" if you are curious! 😊)

Now that you have some minimal understanding of objects in R, think back on the outputs you have seen from various functions in R, especially those whose output seemed a bit verbose (e.g. any of the hypothesis test functions).

Take the function t.test() for example. Here is an example of its application:

> men = c(102,87,101,96,107,101,91,85,108,67,85,82)
> women = c(73,81,111,109,143,95,92,120,93,89,119,79,90,126,62,92,77,106,105,111)
> t.test(x=men, y=women, alternative="two.sided", conf.level=0.95, var.equal=TRUE)

    Two Sample t-test

data:  men and women
t = -0.93758, df = 30, p-value = 0.3559
alternative hypothesis: true difference in means is not equal to 0
95 percent confidence interval:
 -19.016393   7.049727
sample estimates:
mean of x mean of y 
 92.66667  98.65000

What's really happening here is that the t.test() outputs an object associated with the class "htest".

We can see the list sitting behind the scenes in any object by using the unclass() function. Below, we apply this function to the htest object resulting from an application of the t.test() function.

> results = t.test(x=men, y=women, alternative="two.sided", conf.level=0.95, var.equal=TRUE)
> unclass(results)
$statistic
         t 
-0.9375846 

$parameter
df 
30 

$p.value
[1] 0.3559453

$conf.int
[1] -19.016393   7.049727
attr(,"conf.level")
[1] 0.95

$estimate
mean of x mean of y 
 92.66667  98.65000 

$null.value
difference in means 
                  0 

$stderr
[1] 6.381646

$alternative
[1] "two.sided"

$method
[1] " Two Sample t-test"

$data.name
[1] "men and women"

Indeed, the elements in the list above are exactly those discussed in the Value section of the help file for t.test() (Type ?t.test to see this in RStudio.)

However, simply printing results results in the same text we saw earlier.

> results

    Two Sample t-test

data:  men and women
t = -0.93758, df = 30, p-value = 0.3559
alternative hypothesis: true difference in means is not equal to 0
95 percent confidence interval:
 -19.016393   7.049727
sample estimates:
mean of x mean of y 
 92.66667  98.65000 

The reason we get a more consolidated version of the same information printed for us is due to the presence of a (built-in) custom print.htest function, that the (untyped) application of print() uses to accomplish the printing.