OOP in R

S3 system

The S3 support is implemented in the core R and does not require any additional packages. Assuming we want to create an object, which will be used to describe individual for choice situations simulation, we can run:

# Individual object
ind = list(
    characteristics = c("Age", "Income"),
    values = c(30, 2.1)
)
# Assign class
class(ind) = "individual"

Once our custom class assigned, we can add corresponding method to a generic function for our class:

# Add summary method for generic function
summary.individual = function(ind) {
    for (i in seq_along(ind$characteristics)) {
        cat(
            "Individual's ", 
            ind$characteristics[i],
            " is ", 
            ind$values[i],
            "\n"
        )
    }
}

# Apply method to our S3 object
summary(ind)

## Individual's  Age  is  30 
## Individual's  Income  is  2.1

Here we observe how the new method for our individual class was added to summary() default function. The same procedure can be applied to any function.

Now we should make a little point about method inheritance. Imagine we redefine the class of our individual as follows:

# Update class
class(ind) = c("teacher", "individual")

Now, when we will call a function on an object with several classes specified, R will search available methods for the given classes and choose one respecting their priority. Meaning that right now, as there exists no method for teacher class in summary(), R will fall back to a method for other available class individual:

# Apply method to our S3 object
summary(ind)

## Individual's  Age  is  30 
## Individual's  Income  is  2.1

After adding the respecting method for teacher class and re-execute the function:

# Define another method
summary.teacher = function(ind) {
    for (i in seq_along(ind$characteristics)) {
        cat(
            "The teacher's ", 
            ind$characteristics[i],
            " is ", 
            ind$values[i],
            "\n"
        )
    }
}

# Apply method to our S3 object
summary(ind)

## The teacher's  Age  is  30 
## The teacher's  Income  is  2.1

S4 system

The S4 system introduces a separate function for new class definition. Instead of simply assigning a class to an existing object, here we create a template for all other objects of the same class. Not only we define an object’s skeleton, but we define even the default values. For example:

# Define S4 class
individual_s4 = setClass(
    # Define class name
    "individual_s4",
    # Define contents
    slots = c(
        characteristics = "character",
        values = "numeric"
    ),
    # Define default values
    prototype = list(
        characteristics = c("Age", "Income"),
        values = c(30, 2.1)
    ),
    # Validity check
    validity = function(object) {
        if (length(object$characteristics) != length(object$values)) {
            return("The number of supplied values and characteristics do not match")
        }
        return(TRUE)
    }
)

To create a new object of just created class, we can run:

# Create individual
ind = individual_s4(); ind

## An object of class "individual_s4"
## Slot "characteristics":
## [1] "Age"    "Income"
## 
## Slot "values":
## [1] 30.0  2.1

Beware, that previously created methods for summary() function for S3 class will no longer work on a newly created S4 object. S4 class uses slots instead of default list within list structure seen before, which makes it impossible to call slots using $ operator. We will have to rewrite our method to support S4 class:

# Add summary method for generic function
summary.individual_s4 = function(ind) {
    for (i in seq_along(ind@characteristics)) {
        cat(
            "Individual's ", 
            ind@characteristics[i],
            " is ", 
            ind@values[i],
            "\n"
        )
    }
}

# Apply method to our S4 object
summary(ind)

## Individual's  Age  is  30 
## Individual's  Income  is  2.1

To call slots of an object we can use either slot() function or an @ operator. You can find some more information in this blogpost.

RC (or R5) system

As it was previously stated, the main differences between R5 classes and S3 or S4 ones are:

• R5 objects use message-passing OO
• R5 objects are mutable in place

To create a new class in R5 system we can use dedicated function:

# Class creation in R5
individual_r5 = setRefClass(
    # Class name
    "individual_r5",
    # Fields replace slots in R5
    fields = list(
        characteristics = "character",
        values = "numeric"
    )
)

Now let’s create a new individual with R5 system:

# Create new object
ind = individual_r5$new(
    characteristics = c("Age", "Income"),
    values = c(30, 2.2)
); ind

## Reference class object of class "individual_r5"
## Field "characteristics":
## [1] "Age"    "Income"
## Field "values":
## [1] 30.0  2.2

Because the R5 respects $ operator by default, we would need to rewrite our method for summary, identical to the one made for S3 class:

# Add summary method for generic function
summary.individual_r5 = function(ind) {
    for (i in seq_along(ind$characteristics)) {
        cat(
            "Individual's ", 
            ind$characteristics[i],
            " is ", 
            ind$values[i],
            "\n"
        )
    }
}

# Apply method to our R5 object
summary(ind)

## Individual's  Age  is  30 
## Individual's  Income  is  2.2

Alternatively, we can define a method directly within the class definition. To call such methods on object we would need a syntax statement extremely familiar to users of Python:

# Add method to class
individual_r5$methods(
    summarize = function() {
        for (i in seq_along(ind$characteristics)) {
            cat(
                ind$characteristics[i],
                " is ", 
                ind$values[i],
                "\n"
            )
        }
    }
) 

# Apply method
ind$summarize()

## Age  is  30 
## Income  is  2.2

In R5 there exist some common methods shared by all the objects created with setRefClass() function:

• object$copy(), which creates a copy of an existing object
• object$filed(), functioning identically to slots() in S4 for assignment purposes
• object$import() and object$export(), which allow to coerce objects into different classes
• object$initFields()
• object$callSuper()

You can read more about the R5 system in this blogpost.

R6 system

R6 OOP support is brought into R with a separate package. You can install it by running:

# Install R6 dependencies
install.packages("R6")

And then load it into the current environment:

# Load library
library(R6)

The R6 system bring not only the additional feature similar to the more traditional OOP, but are lighter as well. Their implementation avoid some of the issues introduced by S4 and R5 (RC) systems. Among the main features authors state:

• Public and private methods
• Active bindings
• Inheritance (superclasses) which works across packages

# Create individual class in R6 system
individual_r6 = R6Class(
    "individual", 
    public = list(
        characteristics = NULL,
        values = NULL,
        # Initialisation to perform on object creation
        initialize = function(
            characteristics = NA, 
            values = NA
        ){
            self$characteristics = characteristics
            self$values = values
        }
    )
)

The new objects of a given class are created identically to R5 system:

# Create new individual
ind = individual_r6$new(
    characteristics = c("Age", "Income"),
    values = c(25, 1.5)
); ind

## <individual>
##   Public:
##     characteristics: Age Income
##     clone: function (deep = FALSE) 
##     initialize: function (characteristics = NA, values = NA) 
##     values: 25 1.5

R6 keeps support for common $ operator, which allows to declare methods as before:

# Add summary method for generic function
summary.individual_r6 = function(ind) {
    for (i in seq_along(ind$characteristics)) {
        cat(
            "Individual's ", 
            ind$characteristics[i],
            " is ", 
            ind$values[i],
            "\n"
        )
    }
}

# Apply method to our R6 object
summary(ind)

## Individual's  Age  is  25 
## Individual's  Income  is  1.5

Alternatively it’s possible to define active fields within our class, which execute a function when a field is called. But it’s probably best to explore all those additional functionalities of R6 system from more reliable sources.