Introduction

Introduction

The sloop Package

## install.packages('sloop')
library('sloop')

otype(base::abs)

## [1] "base"

otype(3:1)

## [1] "base"

otype(lm(area ~ poptotal, data = ggplot2::midwest))

## [1] "S3"

Base Types vs OO Objects

Base Types vs OO Objects

# base object
is.object(1L)

## [1] FALSE

otype(1L)

## [1] "base"

# OO object
is.object(ggplot2::diamonds)

## [1] TRUE

otype(ggplot2::diamonds)

## [1] "S3"

Base Types vs OO Objects

Only OO objects have a class attribute.

attr(1L, "class")

## NULL

attr(ggplot2::diamonds, "class")

## [1] "tbl_df"     "tbl"        "data.frame"

Base Types vs OO Objects

Base Types

Every R object has a base type of which there are 25.

Important types are NULL, logical, integer, double , complex, character, list and closure

typeof(1L)

## [1] "integer"

typeof(ggplot2::diamonds)

## [1] "list"

typeof(lm)

## [1] "closure"

Base Types — numeric type

The definition of the numeric type is inconsistent:

• numeric is sometimes used as an alias for the double type
• numeric is an alias for integer and double types in S3/S4
• base::is.numeric() checks if the object behaves like a number

Let's run the following expressions and comment on the results.

is.numeric(3.14159)
is.numeric(1L)
typeof(factor('x'))
is.numeric(factor('x'))

S3 — Basics

S3 — Basics

f <- structure(1:3, class = "factor", levels = c("a", "b", "c"))

otype(f)

## [1] "S3"

typeof(f)

## [1] "integer"

class(f)

## [1] "factor"

S3 — Generics

• A generic function (generic) is an interface. It behaves dependent on the class of the passed S3 object.

  This concept is called polymorphism (many shapes).

• The behavior when a S3 object is passed to a generic may be very different from the underlying base type: class-specific methods may do weird stuff!

• The process of looking for a class-specific implementation (method) upon a generic function call is called method dispatch

S3 — Generics

ftype(print)

## [1] "S3"      "generic"

print(f) # Or simply `f`

## [1] a b c
## Levels: a b c

# Integer behaviour
print(unclass(f))

## [1] 1 2 3
## attr(,"levels")
## [1] "a" "b" "c"

S3 — Method Dispatch

S3 — Method Dispatch

mod <- lm(price ~ carat, data = ggplot2::diamonds)
typeof(mod)

## [1] "list"

class(mod)

## [1] "lm"

S3 Basics — Method Dispatch

# Inspect hidden print method for lm objects
s3_get_method(print.lm)

## function (x, digits = max(3L, getOption("digits") - 3L), ...) 
## {
##     cat("\nCall:\n", paste(deparse(x$call), sep = "\n", collapse = "\n"), 
##         "\n\n", sep = "")
##     if (length(coef(x))) {
##         cat("Coefficients:\n")
##         print.default(format(coef(x), digits = digits), print.gap = 2L, 
##             quote = FALSE)
##     }
##     else cat("No coefficients\n")
##     cat("\n")
##     invisible(x)
## }
## <bytecode: 0x7fbefa268660>
## <environment: namespace:stats>

S3 Basics — Exercises

1. Describe the difference between t.test() and t.data.frame(). When is each function called?

2. What class of object does the following code return? What base type is it built on? What attributes does it use?

   x <- ecdf(rpois(100, 10))
   x

3. What class of object does the following code return? What base type is it built on? What attributes does it use?

   x <- table(rpois(100, 5))
   x

S3 Classes

• Part of S3's simplicity is due to lack of formal definition what a class is. For the largest part, this is up to the programmer.

  We have already seen how to generate an OO object using a base type and a class with structure().

• We may use class() to change the class of existing objects. There are no checks if objects of the same class share the same structure!

  class(mod) <- "data.frame"
  mod

  ##  [1] coefficients  residuals     effects       rank          fitted.values
  ##  [6] assign        qr            df.residual   xlevels       call         
  ## [11] terms         model        
  ## <0 rows> (or 0-length row.names)

S3 Classes — Robust Implementation

We recommended to follow the following conventions when creating your own classes:

• Avoid . in class names to prevent confusion with generics

• Provide a constructor function, new_classname(), which generates objects with the desired structure

• Use a validator function, validate_classname() to check that objects of your class have correct values

• "Sharing is caring": provide a user-friendly helper, classname(), which makes it easy for others to generate objects of your class

Case Study — An S3 Class for Prime Numbers

We now demonstrate how to implement a simple S3 class for prime numbers.

new_prime <- function(x = integer()) {
  stopifnot(is.integer(x))
  x <- list(x)
  class(x) <- 'prime'
  x
}

Case Study — An S3 Class for Prime Numbers

validate_prime <- function(x = list()) {
  sapply(
    unique(unlist(x)), function(z) {
      if(!all(z==2 || z %% 2:(z-1) > 0)) {
        stop('Input contains non-prime number(s)!', call. = F)
      }
    } 
  )
  x
}

Case Study — An S3 Class for Prime Numbers

prime <- function(x = integer()) {
    validate_prime(new_prime(x))
}

(x <- prime(c(3L, 5L, 7L, 11L)))

## [[1]]
## [1]  3  5  7 11
## 
## attr(,"class")
## [1] "prime"

## [1] "prime"

S3 Generics and Methods

S3 Generics and Methods

S3 Generics and Methods

s3_method_class() provides all registered methods for a given class.

head(
  s3_methods_class('Date'), 10
)

## # A tibble: 10 x 4
##    generic       class visible source
##    <chr>         <chr> <lgl>   <chr> 
##  1 -             Date  TRUE    base  
##  2 [             Date  TRUE    base  
##  3 [[            Date  TRUE    base  
##  4 [<-           Date  TRUE    base  
##  5 +             Date  TRUE    base  
##  6 as.character  Date  TRUE    base  
##  7 as.data.frame Date  TRUE    base  
##  8 as.list       Date  TRUE    base  
##  9 as.POSIXct    Date  TRUE    base  
## 10 as.POSIXlt    Date  TRUE    base

S3 Generics and Methods

my_generic <- function(x) {
  UseMethod('my_generic')
}

my_generic.default <- function(x) {
  x
}
my_generic.my_class <- function(x) {
  cat("Output for class 'my_class':\n", x)
}

S3 Generics and Methods

y <- structure(x<-1, class = 'my_class')
s3_dispatch(my_generic(x))

##    my_generic.double
##    my_generic.numeric
## => my_generic.default

s3_dispatch(my_generic(y))

## => my_generic.my_class
##  * my_generic.default

S3 Generics and Methods

y <- structure(x<-1, class = 'my_class')
my_generic(x)

## [1] 1

my_generic(y)

## Output for class 'my_class':
##  1

Case Study — A Plot Method for prime Objects

Case Study — A Plot Method for prime Objects

• The image from the previous slide is inspired by this mathexchange post.

• Make sure to checkout 3Blue1Brown's video for a nice explanation of what's going on. 🙃👍🏼

Case Study — A Plot Method for prime Objects

Let's write a method for objects of class prime for the generic plot(). The method should

• take objects of class prime and all additional arguments which can be passed to plot()

• be able to visualise a prime number $p$ in Cartesian and polar coordinates

Source: http://www.maths.usyd.edu.au/

Case Study — A Plot Method for prime Objects

plot.prime <- function(x = list(), coord, ...) {
  x <- unlist(x)
  if(missing(coord)) {
    d <- data.frame(x = x, y = x)
  } else if(coord == "polar") {
    d <- data.frame(x = cos(x * 180/pi) * x, y = sin(x * 180/pi) * x)
  } 
  plot(d, ...)
}

Note that we may pass additional arguments to plot() using ...

Case Study — A Plot Method for prime Objects

# Subset of all prime numbers in 2,...,1e4
x <- 2:1e4
x <- x[sapply(unique(x), function(z) all(z %% 2:(z-1) > 0))]
# Assign 'prime' class
x <- prime(x)

Let's check the method dispatch for plot(x)

s3_dispatch(plot(x))

## => plot.prime
##  * plot.default

Case Study — A Plot Method for prime Objects

plot(x, coord = "polar", pch = 19, cex = 0.5, col = "red")

Exercises

1. Read the source code for t() and t.test() and confirm that t.test() is an S3 generic and not an S3 method. What happens if you create an object with class test and call t() with it? Why?

2. What generics does the table class have methods for?

3. Implement a summary() method for objects of class prime. Use the following strategy:

   1. A summary() method should do some computations and return an object of class summary_print but not print the results

   2. A separate print() method for summary_prime objects should output the results in an appealing format

S3 Inheritance

• In OOP, the concept of Inheritance allows us to derive a new class (child) from an existing one (parent).

• Using inheritance we don't need to start from scratch: the parent may share data, methods etc. with the child

• Inheritance in S3 boils down to a proper assignment of classes (and proper definitions of corresponding methods)

S3 Inheritance

• Note that we may assign multiple classes to an S3 object

  class(x) <- c('A', 'B')
  class(x) <- c('B', 'A')

• Method dispatch always starts with the first element of the class vector and proceeds with subsequent classes if a method is not found.

  This clarifies the informality of the S3 system: there is no formal definition of how classes relate to each other.

S3 Inheritance

# New generic
g <- function(x) UseMethod("g", x)
# Methods for classes 'A' and 'B'
g.A <- function(x) "A"; g.B <- function(x) "B"
# Two objects with different inheritance hierachies
ab <- structure(1, class = c("A", "B")); ba <- structure(1, class = c("B", "A"))
g(ab)

## [1] "A"

g(ba)

## [1] "B"

S3 Inheritance

It's possible to force delegation to the method of the subsequent class (if defined) using NextMethod(). This provides a simple inheritance mechanism:

g.C <- function(x) NextMethod()
ca <- structure(1, class = c("C", "A"))
cb <- structure(1, class = c("C", "B"))
g(ca)

## [1] "A"

g(cb)

## [1] "B"

Notice that inheritance depends on how we define the class vector:

• 'For object ca, class C inherits its g() method from class A'
• 'For object cb, class C inherits its g() method from class B'

S3 Inheritance

print.prime <- function(x) {
     x[[1]]
}

print.mersenne <- function(x) {
  cat('Mersenne primes:', NextMethod(x))
}
print.fermat <- function(x) {
  cat('Fermat primes:', NextMethod(x))
}

S3 Inheritance

x <- prime(c(3L, 7L, 31L))
class(x) <- c('mersenne', class(x))
y <- prime(c(3L, 5L, 17L, 257L))
class(y) <- c('fermat', class(y))
x

## Mersenne primes: 3 7 31

y

## Fermat primes: 3 5 17 257

S3 Inheritance

s3_dispatch(print(x))

## => print.mersenne
## -> print.prime
##  * print.default

s3_dispatch(print(y))

## => print.fermat
## -> print.prime
##  * print.default

S3 Inheritance — Exercises

1. Adjust the constructor function new_prime() such that it allows for subclasses. Then implement a constructor function new_fermat() for objects with subclass fermat.

2. What happens if you subset x (generated as below) using [[?

   x <- prime(c(2L, 3L, 5L))

3. Implement a [[ method which preserves the prime class.