Skip to contents

Method Dispatch of 'squarebrackets'

Source: R/aaa06_squarebrackets_method_dispatch.R
aaa06_squarebrackets_method_dispatch.Rd

This help page gives some additional details regarding the S3 method dispatch used in 'squarebrackets'.

Atomic vs Recursive

Atomic and recursive objects are quite different from each other in some ways:

  • homo- or heterogeneous: an atomic object can only have values of one data type.
    recursive objects can hold values of any combination of data types.

  • nesting: Recursive objects can be nested, while atomic objects cannot be nested.

  • copy and coercion effect: One can coerce or copy a subset of a recursive object, without copying the rest of the object.
    For atomic objects, however, a coercion or copy operation coerces or copies the entire vector (ignoring attributes).

  • vectorization: most vectorized operations generally work on atomic objects, whereas recursive objects often require loops or apply-like functions.

  • recursive subsets: Recursive objects distinguish between "regular" subset operations (in base R using [, [<-), and recursive subset operations (in base R using [[, [[<-).
    See for example the sb2_rec method, or the red = TRUE argument in the sb2_x and sb2_wo methods.
    For atomic objects, these 2 have no meaningful difference (safe for perhaps some minor attribute handling).

  • views: For recursive objects, one can create a view of a recursive subset.
    Subset views do not exist for atomic objects.

Despite these non-trivial differences, the S3 method dispatch does not distinguish between atomic and recursive objects.
I.e. S3 methods check if an object is, for example, an array, but not if it is an atomic array or a recursive array.
(S3 method dispatch actually does distinguish between basic atomic and recursive vectors, but not for dimensional objects like arrays, which is problematic for this specific package).
Therefore, the methods in 'squarebrackets' that perform subset operations on an object, come in the atomic (sb_) and recursive (sb2_) form.
The idx method operates on the indices of an object, but does not operate on the object itself, and so has no distinction between the atomic and recursive form.

Manual Dispatch

The 'squarebrackets' package intentionally exports each function in its S3 method dispatch system.
This is handy for programming purposes.
For example: one can explicitly alias a specific dispatch of a method, if one so desires.
For example like so: 


array_x <- function(x, ...) {

   if(is.atomic(x)) {
     sb_x.array(x, ...)
   }
   else if(is.recursive(x)) {
     sb2_x.array(x, ...)
   }

}

Under certain circumstances, this might help your code to be more clear.

Ellipsis

Due to how the S3 method dispatch system works in 'R', all generic methods have the ellipsis argument (...).
For the user's safety, 'squarebrackets' does check that the user doesn't accidentally add arguments that make no sense for that method (like specifying the inv argument when calling sb_x).