What are these square brackets for S3 classes?

Question

I obtained this from an open source repo on git. This shows the writing of generic and methods for S3 classes. But I do not understand the notations or conventions that the functions are being assigned to. The following are my questions:

The use backticks `` to define the function name. Usually we wouldn't use backticks or even double quotes to assign variables/functions but I see this happening a lot of times. Is this a naming convention?
Why is the . included before the blob name? Usually wouldn't it just be called blob and a method would be method.blob?
Why are there [ brackets there? Especially, [<- and [[<-. Are we performing some sort of double asigning?

Hopefully someone will be able to shed some light on what is ha

#' @export
 `[.blob`  <- function(x, i, ...) {
  new_blob(NextMethod())
}

#' @export
`[<-.blob` <- function(x, i, ..., value) {
  if (!is_raw_list(value)) {
    stop("RHS must be list of raw vectors", call. = FALSE)
  }

  NextMethod()
}

#' @export
 `[[<-.blob` <- function(x, i, ..., value) {
  if (!is.raw(value) && !is.null(value)) {
    stop("RHS must be raw vector or NULL", call. = FALSE)
  }

  if (is.null(value)) {
    x[i] <- list(NULL)
    x
  } else {
    NextMethod()
  }
}

`[` is the subset operator. `[.blob` is a method for subsetting the new `blob` object. So the `.` IS being used in the standard s3 method-dispatch way (as you point out in your question) — SymbolixAU, Apr 10 '18 at 02:34
Special symbols (e.g., backticks, brackets, percent-sign, variables with spaces in the name) cannot be "assigned to" by default. To do so, if you surround it in backticks, it can work. As an example, a variable named `A B` cannot be assigned with `A B <- 1`, whereas `\`A B\` <- 1` works. — r2evans, Apr 10 '18 at 02:37
the `[[<-.blob` functions are for overriding the `[[<-` s3 method for your new `blob` object. The 'normal' base R example is `myvec <- c(1:5); myvec[[3]] <- 2` — SymbolixAU, Apr 10 '18 at 02:40
You can also call functions with backticks, for example `\`[\`(letters, 4)` will give you the 4th letter, it is equivalent to `letters[4]`. — Gregor Thomas, Apr 10 '18 at 02:40
you can use backticks to do a few things, including: calling an infix operator with standard syntax (e.g. `iris[['Species']]` or `\`[[\`(iris, 'Species')`) or referring to a variable/column name that has illegal(?) characters, e.g. if a column of `dat` is named `"0 bad column name"`, you can say `dat$\`0 bad column name\`` but not `dat$0 bad column name`. i think a couple other things too? — lefft, Apr 10 '18 at 02:40

SymbolixAU · Accepted Answer · 2018-04-10T05:50:16.077

Summary

If you're creating a new object in R for which you want 'different' subset and assignment behaviour, you should create the associated methods for these operations.

The . IS working in the way you're expecting - method dispatch
[.blob is overriding the S3 [ subset operator
[<-.blob is overriding the S3 [<- operator (i.e. vector-subset assignment)
[[<-.blob is overriding the S3 [[<- operator (i.e. list-subset assignment)
Special symbols (e.g., backticks, brackets, percent-sign, variables with spaces in the name) cannot be "assigned to" by default. To do so, if you surround it in backticks, it can work. As an example, a variable named A B cannot be assigned with A B <- 1, whereas `A B` <- 1 works (credit @r2evans)

Examples

subset

Taking [.blob as an example, this allows you to create your own subset operation for your blob object.

## Create your own blob object (class)
blob <- 1:5
attr(blob, "class") <- "blob"

## create a subset operator, which in this example just calls the next method in the s3 dispatch chain 
`[.blob` <- function(x, i, j, ...) NextMethod()

As we're not doing anything special in our own subset method, this works like normal R vectors

blob[3]
# [1] 3

However, we can make the subset operation do whatever we want, for example always return the 1st element of the vector

## define the function to always subset the first element
`[.blob` <- function(x, i, j, ...) { i = 1; NextMethod() }

Now your blob object will only ever return the 1st element.

blob[1]
# [1] 1
blob[2]
# [1] 1
blob[3]
# [1] 1

Assignment

Similarly for one of the assignment operators, if you overload [<- with

`[<-.blob` <- function(x, i, j, ...) { i = 5; NextMethod() }

This will always assign the 5th element of your blob object with the new value

blob[1] <- 100
blob
# [1]   1   2   3   4 100
# attr(,"class")
# [1] "blob"

Back ticks

The back-ticks are used so we can assign functions/variables to special symbols.

For example, try to assign a vector to the [ symbol

[ <- 1:5
# Error: unexpected '[' in "["

Whereas surrounding it with ticks lets it pass (although this example is not recommended)

`[` <- 1:5
`[`
# [1] 1 2 3 4 5