S7 does not dispatch on base matrix via new_S3_class("matrix"); resolves to <double>/<integer>/<logical> instead

[frederikfabriciusbjerre]

Summary:

Docs say S7 “behaves like S3.” For base matrices without an explicit class attribute beyond the implicit c("matrix","array", <type>), S3 would try f.matrix before type. In S7, a method registered with new_S3_class("matrix") is not found. Dispatch instead looks for <double> / <integer> / <logical> and errors.

Minimal reproducible example:

library(S7)

# generic
example_generic <- S7::new_generic(
  "example_generic",
  dispatch_args = "x",
  fun = function(x, ...) S7::S7_dispatch()
)

# method intended for base matrices
S7::method(example_generic, S7::new_S3_class("matrix")) <- function(x, ...) {
  "matrix"
}

m <- matrix(c(0,1,0,0), 2, 2)
class(m)
# [1] "matrix" "array"

example_generic(m)
# Error: Can't find method for `example_generic(<double>)`.

Expected:
"matrix method" is called, analogous to S3 where .class2(m) returns c("matrix","array","double","numeric") and f.matrix is tried before type.

Actual:
S7 reports no method for <double>. The S3<matrix> method is ignored.

Notes and related behavior:

• Adding a base-type method fixes it, but that forces users to implement three methods (<double>, <integer>, <logical>) instead of one for "matrix".

• For Matrix package S4 classes, methods::getClass("Matrix") works as expected:

  if (requireNamespace("Matrix", quietly = TRUE)) {
    S7::method(example_generic, methods::getClass("Matrix")) <- function(x, ...) {
      "Matrix"
    }
    example_generic(Matrix::Matrix(m, sparse = TRUE))  # returns "Matrix"
  }

Questions / proposed resolutions:

1. Should S7's dispatch system look at S3/S4 classes first before typeof()?

2. If not, can S7 expose canonical base “dimension” classes like S7::class_matrix and S7::class_array to avoid three separate type methods?

   • Requiring <integer>/<double>/<logical> methods conflates matrices with atomic vectors, so dispatch can ignore matrix semantics (2D shape, dimnames, square checks) and yield behavior different from an intended matrix method.

3. At minimum, docs should clarify that base matrices dispatch by atomic storage type, not by "matrix", and show the recommended pattern.

I am sorry, if I have misunderstood something here, but I am working on a package where methods that work for matrix objects are important.

[hadley]

I don't think class_matrix/class_array would make sense because matrices and arrays aren't true classes (because the values that come after matrix in the class vector can vary). This is going to require some considerable thought (e.g. maybe they're unions like class_numeric?) For now, I'd suggest filling out the complete S3 class vector, i.e. S7::new_S3_class(c("matrix", "array", "double", "numeric")).

[mmaechler]

My gut feeling suggest that S7 should make "proper" use of base .class2() which has been documented to be the way R does S3 method dispatch in such cases, notably matrix. @frederikfabriciusbjerre has smartly and correctly mentioned it I think.

[hadley]

Obviously we want to stay as close to S3 semantics as possible, but I think this might be a case (like with double dispatch) where we want to do something different. I'm uncomfortable with the idea of allowing S7 classes to have varying parents just to support dispatch for matrices/arrays. This is why I think we need to think about it 😄

[frederikfabriciusbjerre]

I understand your caution @hadley, but S7 has a problem with not being very transparent in this manner, and I think that there are design choices that both are flexible, but not as lenient as S3.

At least, I think documentation should somehow reflect how to build methods for matrices and arrays. The documentation is very lean, and I understand that choice as well, but many questions are left unanswered from the docs, for me at least.

[hadley]

Yes, we obviously need to document this. You are just experiecing a part of S7 where that we have not fully explored and you will need to be patient as we build consensus and then document it. My suggested used of new_S3_class() should unblock you in the mean time.

[frederikfabriciusbjerre]

@hadley thank you for your help. I understand that S7 is in the earlier stages and I like the fact that these discussions are still ongoing and everything is not set in stone. Let me know if I can contribute to this problem in any capacity!

The suggested new_S3_class() does not solve my problem currently.

library(S7)

# generic
example_generic <- S7::new_generic(
    "example_generic",
    dispatch_args = "x",
    fun = function(x, ...) S7::S7_dispatch()
)

# method intended for base matrices
S7::method(example_generic, S7::new_S3_class(c("matrix", "array", "double", "numeric"))) <- function(x, ...) {
    "matrix"
}

m <- matrix(c(0,1,0,0), 2, 2)
.class2(m)
# [1] "matrix"  "array"   "double"  "numeric"

example_generic(m)
# Error: Can't find method for `example_generic(<double>)`.

[hadley]

Ok, that's good to know. Thanks.

[frederikfabriciusbjerre]

Do you have any other suggestions as to how to solve it?

[frederikfabriciusbjerre]

I chose to just using the actual storage types as methods and then doing a is.matrix check inside the method as a temporary solution.

[alexpghayes]

However this resolves, I would also appreciate documentation about how an S7 class can have a matrix as a property.