R6 classes in R Programming - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is an R6 class in R?

An R6 class is a way to create objects with methods and fields in R, allowing for object-oriented programming with encapsulation and inheritance.

beginner

How do you create a new R6 class?

Use the <code>R6Class()</code> function, specifying the class name, public methods, and fields inside it.

intermediate

What is the difference between public and private members in R6 classes?

Public members can be accessed from outside the object, while private members can only be accessed inside the class methods.

beginner

How do you create an object from an R6 class?

Call the <code>$new()</code> method on the R6 class to create a new object instance.

intermediate

Can R6 classes inherit from other R6 classes?

Yes, R6 classes support inheritance by specifying the inherit argument in R6Class().

Which function is used to define an R6 class?

A R6Class()

B class()

C new()

D createClass()

The R6Class() function is used to define R6 classes in R.

How do you access a public method named greet from an R6 object obj?

A obj.greet()

B obj$greet()

C obj->greet()

D obj[greet]

In R6, methods and fields are accessed using the $ operator, so obj$greet() calls the method.

What does the $new() method do in R6?

A Changes class name

B Deletes an object

C Lists all methods

D Creates a new object instance

The $new() method creates a new instance of the R6 class.

Which of these is true about private members in R6 classes?

A They can only be accessed inside class methods

B They are accessible from outside the object

C They are the same as public members

D They do not exist in R6

Private members are hidden from outside and only accessible inside the class methods.

How do you specify inheritance in an R6 class?

A Inheritance is not supported

B Using extends keyword

C Using the inherit argument in R6Class()

D Using super() function

Inheritance is specified by the inherit argument inside R6Class().

Explain how to create an R6 class with a public field and a method that prints a message.

Think about how you define fields and methods inside the public list.

Describe the difference between public and private members in R6 classes and why encapsulation is useful.

Consider how controlling access helps protect data inside objects.

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