Introduction to the R6DS Package

The reference class

The first question is: what is the reference class?

As an R user, you should know that, in R, everything is an object. This includes the variables like vector, list, data.frame, and etc., and even all the functions (closures).

Almost all the variables (if the functions are also variables, yes, they are, because the function name can be changed to another function) are assigned or passed by value (this is termed pass-by-value).

For example, consider the simple assignment:

x <- 0
y <- x

R will copy the value of x to y, and they are supposed to be two different variables which occupy different memory pieces. However, in practice, the new memory will not be allocated for y immediately when running y <- x. R will do a fake pass-by-reference (that we will explain later), and later new memory will be allocated for y(or x), once the value of x(or y) is changed. So anyway, x to y are supposed to be in different places in the memory.

Now consider the pass:

# define a function which changes the value of the passed variable,
# and then the new one
func <- function(val){ val <- -1; return(val) }

# remember that x = 0
z <- func(x)
x
#> [1] 0
z
#> [1] -1

R will copy the variable x to a new variable val, change the value of val, and then return it by value! (copy the local val to the new variable z, and then kill val when the function exits) So the function actually copies twice in both passing and returning.

It should be noticed that, if the value of val is not going to be changed inside the function func, that is, func is defined to be a immutable function like, for example,

# define a function which changes the value of the passed variable,
# and then the new one
func <- funcion(val){ print(val) }

then R will pass val by reference (that we will explain later). But anyway, you are changing another variable val instead of x inside the function.

The idea of pass-by-reference comes from a good dream that we hope when we do something like

func <- function(val){ val <- -1 }
func(x)

the global x will be changed…

I will explain why it is a good dream later. But now let’s focus on the pass-by-reference.

The pass-by-reference in assignment implies that, in the assignment action, for example,

y <- x

the variable y will be an alias (the term is a “reference”) of x, which means that both x and y will share the same memory. Once you change the value of either of the two, the other will be changed automatically.

Now consider the function

func <- function(val){ val <- -1 }
func(x)

If the function is pass-by-reference, then argument val will share the same memory of x when you run func(x), and the value of the global x will be changed after calling the function.

So when we do pass-by-reference, no new memory is allocated, the original variable will have an alias. When you change the value of the alias, the original one will also be changed.

The reference class follows the same rule, that is, any object or instance of this class will always be passed-by-reference.

Data structures

R is becoming a more and more sophisticated language. R users program by using R to make achievements in data sciences. Now the question is that “Are you really happy with only pass-by-value?” or “whether only the pass-by-value is sufficient?”

The answer is NO, because we are doing much more than expected in data sciences, and some ideas from the data structures are now needed, but the implementation of these ideas needs the pass-by-reference!

So the dream is that “we hope that we can input something into some function and the function will change its value!”

Or, for some people, “we really miss the pointers or references in Fortran, C, C++, and etc.”

Even R says no itself due to the fact the Reference Class following the S4 class has been implemented. And then the much more efficient R6 class was implemented and available in the R6 package. I employ the R6 class to implement the data structures.

Suppose that you want to design and implement some algorithm. The most efficient solution is, for example, to use the recursion, in which you pass a variable into some function, the function will call itself and pass the same variable into it. The corresponding algorithm requires that the variable will be changed inside the recursion. See for example, the traverse algorithm in the binary-search-tree, in which, if we want to have a copy of these traversed elements, then it is desirable to pass-by-reference a container (vector, list, data.frame and etc.) into the recursive traverse function. Once an element in the tree is reached, its value will be copied into the container.

Now you see that, the data structures and the algorithms do require the pass-by-reference feature!