R6 classes in R Programming - Step-by-Step Execution

Concept Flow - R6 classes

Define R6 Class

↓

Create Object (Instance)

↓

Call Methods

↓

Modify or Access Fields

↓

Use or Update Object State

↓

End or Reuse Object

This flow shows how you define an R6 class, create an object, call its methods, and access or modify its fields step-by-step.

Execution Sample

R Programming

library(R6)
Person <- R6Class("Person",
  public = list(
    name = NULL,
    initialize = function(name) { self$name <- name },
    greet = function() { paste0("Hello, ", self$name) }
  )
)
p <- Person$new("Alice")
p$greet()

This code defines a Person class with a name field and greet method, creates an instance named Alice, and calls greet.

Execution Table

Step	Action	Evaluation	Result
1	Load R6 library	library(R6)	R6 functions available
2	Define Person class	R6Class("Person", ...)	Class Person created
3	Create object p	Person$new("Alice")	Object p with name='Alice'
4	Call p$greet()	p$greet()	"Hello, Alice"
5	End	No more commands	Execution stops

💡 No more commands to execute, program ends

Variable Tracker

Variable	Start	After Step 3	After Step 4	Final
p$name	NULL	"Alice"	"Alice"	"Alice"
p$greet()	Function	Function	Function	Function

Key Moments - 2 Insights

Why do we use self$name inside methods instead of just name?

Inside methods, self$name refers to the object's field. Using just name would look for a local variable, which does not exist. See Step 4 in execution_table where self$name is used.

What happens when we call Person$new("Alice")?

It creates a new object p and runs initialize, setting p$name to "Alice". See Step 3 in execution_table.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of p$name after Step 3?

A "Hello, Alice"

B NULL

C "Alice"

D Function

💡 Hint

Check the 'Result' column in Step 3 of execution_table.

At which step does the greet method return the greeting string?

A Step 4

B Step 2

C Step 3

D Step 5

💡 Hint

Look at the 'Evaluation' and 'Result' columns in Step 4.

If we change initialize to set self$name <- "Bob", what will p$greet() return?

A "Hello, Alice"

B "Hello, Bob"

C NULL

D Error

💡 Hint

Refer to how initialize sets self$name in Step 3 and greet uses self$name in Step 4.

Concept Snapshot

R6 classes in R create objects with fields and methods.
Use R6Class() to define a class.
$new() creates an instance.
Use self$field inside methods to access fields.
Call methods with $ like obj$method().

Full Transcript

This visual execution shows how R6 classes work in R. First, we load the R6 library to get the tools. Then we define a class called Person with a field name and methods initialize and greet. When we create an object p with Person$new("Alice"), the initialize method sets p$name to "Alice". Calling p$greet() returns the string "Hello, Alice" by accessing self$name inside the method. The variable tracker shows how p$name changes from NULL to "Alice" after creation and stays the same after greeting. Key moments clarify why self$name is needed inside methods and what happens during object creation. The quiz tests understanding of variable values at each step and the effect of changing initialize. This step-by-step trace helps beginners see how R6 classes create and use objects in R.

Practice

1. What is the main purpose of using R6Class() in R?

easy

A. To create plots and visualizations

B. To perform statistical tests on data

C. To import data from external files

D. To create a class that groups data and functions together

Solution

1. Step 1: Understand the role of R6Class()

   R6Class() is used to define a class that can hold both data (fields) and functions (methods) together.

2. Step 2: Compare with other options

   Creating plots and visualizations, performing statistical tests on data, and importing data from external files are unrelated tasks, not the purpose of R6Class().

3. Final Answer:

   To create a class that groups data and functions together -> Option D

4. Quick Check:

   R6Class() = class with data and methods [OK]

Hint: R6Class groups data and actions in one place [OK]

Common Mistakes:

• Thinking R6Class is for data analysis only
• Confusing R6Class with plotting functions
• Assuming R6Class imports data

2. Which of the following is the correct way to define a method inside an R6 class?

easy

A. methods = { my_method <- function() { print(self$field) } }

B. methods = list(my_method = function() { print(self$field) })

C. method <- function() { print(self$field) }

D. methods = function(my_method) { print(self$field) }

Solution

1. Step 1: Recall R6 method syntax

   Methods are defined inside a list with names as method names and values as functions, e.g., methods = list(name = function() {...}).

2. Step 2: Check each option

   methods = list(my_method = function() { print(self$field) }) correctly uses a list with a named function. The other options do not follow the required list structure.

3. Final Answer:

   methods = list(my_method = function() { print(self$field) }) -> Option B

4. Quick Check:

   Methods = list of named functions [OK]

Hint: Methods must be in a named list inside R6Class [OK]

Common Mistakes:

• Defining methods as a single function instead of list
• Using assignment inside methods block incorrectly
• Omitting the list() wrapper

3. What will be the output of this R code?

Person <- R6Class("Person",
  public = list(
    name = NULL,
    initialize = function(name) {
      self$name <- name
    },
    greet = function() {
      paste0("Hello, ", self$name, "!")
    }
  )
)
p <- Person$new("Anna")
p$greet()

medium

A. NULL

B. Error: object 'self' not found

C. "Hello, Anna!"

D. "Hello, name!"

Solution

1. Step 1: Understand object creation and initialization

   The class Person has a field 'name' set during initialization with self$name <- name. The object p is created with name "Anna".

2. Step 2: Evaluate the greet method

   The greet method returns paste0("Hello, ", self$name, "!"), which becomes "Hello, Anna!" for p.

3. Final Answer:

   "Hello, Anna!" -> Option C

4. Quick Check:

   p$greet() = "Hello, Anna!" [OK]

Hint: self$name holds the name; greet returns greeting string [OK]

Common Mistakes:

• Expecting NULL because name is NULL initially
• Confusing self with private or global variables
• Thinking greet prints instead of returns

4. Identify the error in this R6 class definition:

Car <- R6Class("Car",
  public = list(
    speed = 0,
    accelerate = function() {
      speed <- speed + 10
    }
  )
)
c <- Car$new()
c$accelerate()
c$speed

medium

A. The method should use self$speed, not speed alone

B. The class name must be lowercase

C. The accelerate method must return speed explicitly

D. The speed field cannot be initialized to 0

Solution

1. Step 1: Check variable usage inside method

   Inside accelerate(), speed <- speed + 10 updates a local variable speed, not the field. It should be self$speed to update the object's field.

2. Step 2: Verify other options

   Class names can be uppercase, methods don't need explicit return, and initializing speed to 0 is valid.

3. Final Answer:

   The method should use self$speed, not speed alone -> Option A

4. Quick Check:

   Use self$ to access fields inside methods [OK]

Hint: Use self$ to access or change fields inside methods [OK]

Common Mistakes:

• Forgetting self$ prefix for fields
• Assuming local variable changes affect fields
• Thinking class names must be lowercase

5. You want to create an R6 class BankAccount with a field balance starting at 0 and methods deposit(amount) and withdraw(amount). The withdraw method should not allow the balance to go below zero. Which code snippet correctly implements this?

hard

A. BankAccount <- R6Class("BankAccount",
public = list(
balance = 0,
deposit = function(amount) {
self$balance <- self$balance + amount
},
withdraw = function(amount) {
if (self$balance >= amount) {
self$balance <- self$balance - amount
}
}
)
)

B. BankAccount <- R6Class("BankAccount",
public = list(
balance = 0,
deposit = function(amount) {
balance <- balance + amount
},
withdraw = function(amount) {
balance <- balance - amount
}
)
)

C. BankAccount <- R6Class("BankAccount",
public = list(
balance = 0,
deposit = function(amount) {
self$balance <- amount
},
withdraw = function(amount) {
self$balance <- self$balance - amount
}
)
)

D. BankAccount <- R6Class("BankAccount",
public = list(
balance = 0,
deposit = function(amount) {
self$balance <- self$balance + amount
},
withdraw = function(amount) {
self$balance <- self$balance - amount
}
)
)

Solution

1. Step 1: Check deposit method correctness

   Deposit should add amount to self$balance. Some options do this correctly; others do not use self$ or overwrite balance incorrectly.

2. Step 2: Check withdraw method logic

   Withdraw must check if balance >= amount before subtracting to avoid negative balance. Only BankAccount <- R6Class("BankAccount", public = list( balance = 0, deposit = function(amount) { self$balance <- self$balance + amount }, withdraw = function(amount) { if (self$balance >= amount) { self$balance <- self$balance - amount } } ) ) has this check.

3. Final Answer:

   The code snippet with self$balance updates and balance check before withdrawal -> Option A

4. Quick Check:

   Use self$ and check balance before withdrawal [OK]

Hint: Withdraw must check balance before subtracting [OK]

Common Mistakes:

• Not using self$ to update balance
• Overwriting balance instead of adding
• Allowing negative balance without check