1

I'm certain there is a really basic answer to this, which is possibly why I'm finding it hard to actually search for and find an answer. But... can somebody please explain exactly what it means to combine $ and () in the same syntax in R?

For example from this vignette:

https://cran.r-project.org/web/packages/pivottabler/vignettes/v00-vignettes.html

library(pivottabler)
pt <- PivotTable$new()
pt$addData(bhmtrains)
pt$renderPivot()

I never encountered this while learning R until now years later. I'm seeing it more and more lately but it is not intuitive to me?

$ is usually used when accessing sub-structures of objects in R like columns of a data frame e.g dataframe$column1, while () is usually used to enclose all arguments of a named function e.g rnorm(10,0,1)

What does it mean when they are used together? e.g. x$y(z)

jay.sf
  • 60,139
  • 8
  • 53
  • 110
Roasty247
  • 679
  • 5
  • 20
  • Try `class(pt$addData)` which should answer your question. – jay.sf Jan 14 '22 at 13:53
  • it returns "function". But why does a function need a $ in the middle of it? – Roasty247 Jan 14 '22 at 13:58
  • 1
    `pt` is an `"R6"` class, to which functions can be added in this way, also try `class(pt)` – jay.sf Jan 14 '22 at 14:02
  • 2
    It is *analogous* (though technically different-enough in several ways) from `funcs <- list(mu = mean, sigma = sd); funcs$mu(runif(10)); funcs$sigma(runif(10))`. The `$` is a list/frame-accessor ("method"), and the `()` is the argument-less function call, they are unrelated. – r2evans Jan 14 '22 at 14:07
  • Somebody post an answer ... ? – Ben Bolker Jan 14 '22 at 16:14

1 Answers1

1

The dollar is a generic operator used to extract or replace parts of recursive objects, such as lists and data frames.

A list is an object consisting of an ordered collection of objects (including other lists), perhaps of different types, said components.

Consider the following list:

L <- list(a = 1, f = function() message("hello"))

This is a list with two components: a and f. The first is a number and the second is a function. By applying the $-operator, you extract the value of the component, which can also be reassigned:

L$a 
# 1
L$a <- 2
L$a 
# 2

In the case of the f component, because it is a function, you get its body:

L$f 
# function() message("hello")

This is in line with each function identifier: its value is the function's body. It is not surprising that, applying the parentheses to the function's identifier, you execute the function, that is:

L$f()
# hello

This opens the doors to very powerful structures, where you can store both data and the functions to manipulate them.

This logic resembles the classes used in the OOP world. Of course, you need much more features, such instantiations, inheritance. Such mechanisms are provided, for example, by the R6 package, which you mention in your tag.

library(R6)
A <- R6Class("A", list(f=function() message("hello") ))
a <- A$new()
a$f()
# hello

A is an R6 class, so A$new() creates a new instance of the class, a, by means of the class function new. As you can see, this function is called using a syntax (and a logic) similar to L$f() above. The instance a inherits the class function f, said method here, and a$f() executes it.

antonio
  • 10,629
  • 13
  • 68
  • 136