Performance

library(S7)

The dispatch performance should be roughly on par with S3 and S4, though as this is implemented in a package there is some overhead due to .Call vs .Primitive.

Text := new_class(parent = class_character)
Number := new_class(parent = class_double)

x <- Text("hi")
y <- Number(1)

foo_S7 := new_generic("x")
method(foo_S7, Text) <- function(x, ...) paste0(x, "-foo")

foo_S3 <- function(x, ...) {
  UseMethod("foo_S3")
}

foo_S3.Text <- function(x, ...) {
  paste0(x, "-foo")
}

library(methods)
setOldClass(c("Number", "numeric", "S7_object"))
setOldClass(c("Text", "character", "S7_object"))

setGeneric("foo_S4", function(x, ...) standardGeneric("foo_S4"))
#> [1] "foo_S4"
setMethod("foo_S4", c("Text"), function(x, ...) paste0(x, "-foo"))

# Measure performance of single dispatch
bench::mark(foo_S7(x), foo_S3(x), foo_S4(x))
#> # A tibble: 3 × 6
#>   expression      min   median `itr/sec` mem_alloc `gc/sec`
#>   <bch:expr> <bch:tm> <bch:tm>     <dbl> <bch:byt>    <dbl>
#> 1 foo_S7(x)    2.21µs   2.71µs   361659.        0B     36.2
#> 2 foo_S3(x)  901.99ns   1.11µs   816532.        0B     81.7
#> 3 foo_S4(x)    1.02µs   1.23µs   784934.        0B      0

bar_S7 := new_generic(c("x", "y"))
method(bar_S7, list(Text, Number)) <- function(x, y, ...) paste0(x, "-", y, "-bar")

setGeneric("bar_S4", function(x, y, ...) standardGeneric("bar_S4"))
#> [1] "bar_S4"
setMethod("bar_S4", c("Text", "Number"), function(x, y, ...) paste0(x, "-", y, "-bar"))

# Measure performance of double dispatch
bench::mark(bar_S7(x, y), bar_S4(x, y))
#> # A tibble: 2 × 6
#>   expression        min   median `itr/sec` mem_alloc `gc/sec`
#>   <bch:expr>   <bch:tm> <bch:tm>     <dbl> <bch:byt>    <dbl>
#> 1 bar_S7(x, y)   4.59µs   5.45µs   182579.        0B     54.8
#> 2 bar_S4(x, y)   2.54µs   3.03µs   326164.        0B     65.2

A potential optimization is caching based on the class names, but lookup should be fast without this.

The following benchmark generates a class hierarchy of different levels and lengths of class names and compares the time to dispatch on the first class in the hierarchy vs the time to dispatch on the last class.

We find that even in very extreme cases (e.g. 100 deep hierarchy 100 of character class names) the overhead is reasonable, and for more reasonable cases (e.g. 10 deep hierarchy of 15 character class names) the overhead is basically negligible.

library(S7)

gen_character <- function (n, min = 5, max = 25, values = c(letters, LETTERS, 0:9)) {
  lengths <- sample(min:max, replace = TRUE, size = n)
  values <- sample(values, sum(lengths), replace = TRUE)
  starts <- c(1, cumsum(lengths)[-n] + 1)
  ends <- cumsum(lengths)
  mapply(function(start, end) paste0(values[start:end], collapse=""), starts, ends)
}

bench::press(
  num_classes = c(3, 5, 10, 50, 100),
  class_nchar = c(15, 100),
  {
    # Construct a class hierarchy with that number of classes
    Text := new_class(parent = class_character)
    parent <- Text
    classes <- gen_character(num_classes, min = class_nchar, max = class_nchar)
    env <- new.env()
    for (x in classes) {
      assign(x, new_class(x, parent = parent), env)
      parent <- get(x, env)
    }

    # Get the last defined class
    cls <- parent

    # Construct an object of that class
    x <- do.call(cls, list("hi"))

    # Define a generic and a method for the last class (best case scenario)
    foo_S7 := new_generic("x")
    method(foo_S7, cls) <- function(x, ...) paste0(x, "-foo")

    # Define a generic and a method for the first class (worst case scenario)
    foo2_S7 := new_generic("x")
    method(foo2_S7, S7_object) <- function(x, ...) paste0(x, "-foo")

    bench::mark(
      best = foo_S7(x),
      worst = foo2_S7(x)
    )
  }
)
#> # A tibble: 20 × 8
#>    expression num_classes class_nchar      min   median `itr/sec` mem_alloc `gc/sec`
#>    <bch:expr>       <dbl>       <dbl> <bch:tm> <bch:tm>     <dbl> <bch:byt>    <dbl>
#>  1 best                 3          15   2.25µs   2.79µs   351992.        0B     70.4
#>  2 worst                3          15   2.34µs   2.79µs   354650.        0B     70.9
#>  3 best                 5          15   2.21µs   2.62µs   373131.        0B     74.6
#>  4 worst                5          15    2.3µs   2.79µs   358818.        0B     71.8
#>  5 best                10          15   2.17µs   2.62µs   376193.        0B     75.3
#>  6 worst               10          15   2.42µs   2.91µs   341407.        0B     34.1
#>  7 best                50          15   2.34µs   2.79µs   355180.        0B     35.5
#>  8 worst               50          15    3.2µs   3.81µs   262513.        0B     26.3
#>  9 best               100          15   2.46µs   2.99µs   330044.        0B     66.0
#> 10 worst              100          15    4.3µs   5.04µs   198445.        0B     39.7
#> 11 best                 3         100   2.34µs   2.83µs   349229.        0B     69.9
#> 12 worst                3         100    2.3µs   2.79µs   343238.        0B     68.7
#> 13 best                 5         100    2.3µs   2.75µs   344661.        0B     68.9
#> 14 worst                5         100   2.54µs   3.08µs   318760.        0B     31.9
#> 15 best                10         100   2.21µs   2.83µs   339766.        0B     68.0
#> 16 worst               10         100   2.87µs   3.36µs   282309.        0B     56.5
#> 17 best                50         100   2.38µs   2.87µs   333758.        0B     33.4
#> 18 worst               50         100   5.29µs   6.07µs   161379.        0B     32.3
#> 19 best               100         100   2.38µs   2.91µs   324539.        0B     64.9
#> 20 worst              100         100   8.28µs   8.98µs   102446.        0B     20.5

And the same benchmark using double-dispatch

bench::press(
  num_classes = c(3, 5, 10, 50, 100),
  class_nchar = c(15, 100),
  {
    # Construct a class hierarchy with that number of classes
    Text := new_class(parent = class_character)
    parent <- Text
    classes <- gen_character(num_classes, min = class_nchar, max = class_nchar)
    env <- new.env()
    for (x in classes) {
      assign(x, new_class(x, parent = parent), env)
      parent <- get(x, env)
    }

    # Get the last defined class
    cls <- parent

    # Construct an object of that class
    x <- do.call(cls, list("hi"))
    y <- do.call(cls, list("ho"))

    # Define a generic and a method for the last class (best case scenario)
    foo_S7 := new_generic(c("x", "y"))
    method(foo_S7, list(cls, cls)) <- function(x, y, ...) paste0(x, y, "-foo")

    # Define a generic and a method for the first class (worst case scenario)
    foo2_S7 := new_generic(c("x", "y"))
    method(foo2_S7, list(S7_object, S7_object)) <- function(x, y, ...) paste0(x, y, "-foo")

    bench::mark(
      best = foo_S7(x, y),
      worst = foo2_S7(x, y)
    )
  }
)
#> # A tibble: 20 × 8
#>    expression num_classes class_nchar      min   median `itr/sec` mem_alloc `gc/sec`
#>    <bch:expr>       <dbl>       <dbl> <bch:tm> <bch:tm>     <dbl> <bch:byt>    <dbl>
#>  1 best                 3          15   3.03µs   3.69µs   257395.        0B     51.5
#>  2 worst                3          15   3.36µs   4.06µs   233308.        0B     70.0
#>  3 best                 5          15   3.12µs   3.81µs   249737.        0B     74.9
#>  4 worst                5          15   3.36µs   4.02µs   240406.        0B     48.1
#>  5 best                10          15    3.2µs   3.85µs   244318.        0B     73.3
#>  6 worst               10          15   3.53µs   4.22µs   224484.        0B     67.4
#>  7 best                50          15   3.36µs   3.98µs   239074.        0B     71.7
#>  8 worst               50          15   5.17µs   6.07µs   161576.        0B     32.3
#>  9 best               100          15   3.65µs   4.35µs   224651.        0B     67.4
#> 10 worst              100          15   7.05µs   8.08µs   124100.        0B     24.8
#> 11 best                 3         100   3.32µs   3.94µs   245437.        0B     73.7
#> 12 worst                3         100   3.48µs   4.06µs   245332.        0B     49.1
#> 13 best                 5         100   3.36µs    3.9µs   256528.        0B     51.3
#> 14 worst                5         100   3.85µs   4.43µs   207280.        0B     62.2
#> 15 best                10         100   3.12µs   3.77µs   251849.        0B     50.4
#> 16 worst               10         100    4.3µs   4.71µs   201257.        0B     60.4
#> 17 best                50         100   3.32µs   3.77µs   250217.        0B     75.1
#> 18 worst               50         100   9.47µs   9.96µs    94092.        0B     18.8
#> 19 best               100         100   3.65µs    4.1µs   234979.        0B     47.0
#> 20 worst              100         100  16.52µs  17.18µs    54556.        0B     16.4