RefCell overview in Rust - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is RefCell in Rust?

RefCell is a smart pointer that allows mutable borrowing checked at runtime instead of compile time. It enables interior mutability, letting you change data even when the RefCell itself is immutable.

intermediate

How does RefCell enforce borrowing rules?

RefCell enforces Rust's borrowing rules at runtime by tracking borrows. It allows multiple immutable borrows or one mutable borrow at a time. If rules are broken, it panics during execution.

beginner

What is 'interior mutability' in Rust?

Interior mutability means you can change data inside an immutable container. RefCell provides this by allowing mutation through runtime-checked borrows, even if the RefCell itself is not mutable.

intermediate

What methods does RefCell provide to borrow data?

RefCell provides borrow() for immutable access and borrow_mut() for mutable access. Both return smart pointers (Ref and RefMut) that enforce borrowing rules at runtime.

intermediate

What happens if you try to borrow mutably while an immutable borrow exists in RefCell?

RefCell will panic at runtime because it violates Rust's borrowing rules. Only one mutable borrow or multiple immutable borrows are allowed at the same time.

What does RefCell allow you to do in Rust?

A Mutate data inside an immutable container with runtime checks

B Mutate data only if the container is mutable at compile time

C Share data between threads safely

D Prevent any mutation of data

RefCell allows interior mutability by enabling mutation inside an immutable container with runtime borrow checking.

Which method of RefCell gives you a mutable borrow?

A borrow_mut()

B borrow()

C get()

D mut_borrow()

borrow_mut() returns a mutable borrow checked at runtime.

What happens if you try to call borrow_mut() while an immutable borrow exists?

A It compiles but returns None

B It allows both borrows

C It silently ignores the mutable borrow

D It panics at runtime

RefCell panics at runtime if borrowing rules are violated.

What is the main difference between RefCell and regular references in Rust?

A There is no difference

B <code>RefCell</code> is immutable, references are mutable

C <code>RefCell</code> checks borrowing rules at runtime, references at compile time

D <code>RefCell</code> is thread-safe, references are not

RefCell enforces borrowing rules at runtime, unlike references which are checked at compile time.

Which of these is a use case for RefCell?

A When you want to share data safely across threads

B When you need interior mutability in single-threaded code

C When you want to avoid any runtime checks

D When you want to make data immutable

RefCell is used for interior mutability in single-threaded scenarios.

Explain what RefCell is and how it helps with interior mutability in Rust.

Think about how Rust normally restricts mutation and how RefCell changes that.

Describe the borrowing rules enforced by RefCell and what happens if they are violated.

Consider how RefCell tracks borrows during program execution.

Practice

1. What is the main purpose of RefCell in Rust?

easy

A. To enable safe sharing of data across multiple threads

B. To enforce borrowing rules at compile time

C. To replace all uses of Box for heap allocation

D. To allow mutation of data even when the data is borrowed immutably

Solution

1. Step 1: Understand RefCell's role

   RefCell allows mutation of data even when it is borrowed immutably by enforcing borrowing rules at runtime.

2. Step 2: Compare with other options

   RefCell is not for multi-threading (that's for Mutex or RwLock), nor does it replace Box or enforce compile-time checks.

3. Final Answer:

   To allow mutation of data even when the data is borrowed immutably -> Option D

4. Quick Check:

   RefCell enables interior mutability = B [OK]

Hint: RefCell allows changing data inside immutable references [OK]

Common Mistakes:

• Confusing RefCell with thread-safe types
• Thinking RefCell enforces compile-time checks
• Assuming RefCell replaces Box for heap allocation

2. Which of the following is the correct way to create a RefCell containing an integer value 10?

easy

A. let x = RefCell::create(10);

B. let x = RefCell(10);

C. let x = RefCell::new(10);

D. let x = new RefCell(10);

Solution

1. Step 1: Recall RefCell creation syntax

   RefCell is created using the associated function new like RefCell::new(value).

2. Step 2: Check options

   Only let x = RefCell::new(10); uses the correct syntax. Options A, B, and D are invalid Rust syntax for RefCell creation.

3. Final Answer:

   let x = RefCell::new(10); -> Option C

4. Quick Check:

   Use RefCell::new(value) to create [OK]

Hint: Use RefCell::new(value) to create a RefCell [OK]

Common Mistakes:

• Using RefCell(10) without ::new
• Trying to call RefCell::create which doesn't exist
• Using new RefCell(10) like other languages

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

use std::cell::RefCell;

fn main() {
    let data = RefCell::new(5);
    *data.borrow_mut() += 10;
    println!("{}", data.borrow());
}

medium

A. 15

B. 5

C. Compilation error

D. Runtime panic

Solution

1. Step 1: Understand the code behavior

   The RefCell holds 5 initially. The mutable borrow adds 10, changing the value to 15.

2. Step 2: Print the current value

   The immutable borrow prints the updated value, which is 15.

3. Final Answer:

   15 -> Option A

4. Quick Check:

   RefCell allows mutation inside borrow_mut = 15 [OK]

Hint: borrow_mut lets you change the value inside RefCell [OK]

Common Mistakes:

• Expecting original value 5 to print
• Thinking borrow_mut causes compile error
• Confusing borrow() and borrow_mut() usage

4. What error occurs when you try to borrow a RefCell mutably twice at the same time?

use std::cell::RefCell;

fn main() {
    let cell = RefCell::new(10);
    let mut1 = cell.borrow_mut();
    let mut2 = cell.borrow_mut();
}

medium

A. Runtime panic due to multiple mutable borrows

B. Syntax error: borrow_mut() not found

C. No error, code runs fine

D. Compile-time borrow checker error

Solution

1. Step 1: Understand RefCell borrowing rules

   RefCell enforces borrowing rules at runtime, so multiple mutable borrows cause a panic at runtime.

2. Step 2: Analyze the code

   Two mutable borrows happen simultaneously, which is forbidden and triggers a runtime panic.

3. Final Answer:

   Runtime panic due to multiple mutable borrows -> Option A

4. Quick Check:

   RefCell panics on multiple mutable borrows [OK]

Hint: Only one mutable borrow allowed at runtime in RefCell [OK]

Common Mistakes:

• Expecting compile-time error instead of runtime panic
• Thinking multiple mutable borrows are allowed
• Confusing syntax errors with borrowing errors

5. You want to safely mutate a value inside a struct shared only within one thread. Which is the best way to do this using RefCell?

struct Counter {
    count: RefCell<i32>,
}

impl Counter {
    fn new() -> Self {
        Counter { count: RefCell::new(0) }
    }

    fn increment(&self) {
        // Fill in this method
    }
}

What code should replace the comment to increment the count safely?

hard

A. self.count = RefCell::new(*self.count.borrow() + 1);

B. *self.count.borrow_mut() += 1;

C. self.count.borrow() += 1;

D. self.count += 1;

Solution

1. Step 1: Understand how to mutate RefCell inside a method

   To change the value inside RefCell, we borrow it mutably with borrow_mut() and then modify the dereferenced value.

2. Step 2: Check each option

   *self.count.borrow_mut() += 1; correctly mutably borrows and increments. self.count = RefCell::new(*self.count.borrow() + 1); tries to replace the RefCell which is not allowed. self.count.borrow() += 1; tries to mutate an immutable borrow. self.count += 1; tries to add directly to RefCell which is invalid.

3. Final Answer:

   *self.count.borrow_mut() += 1; -> Option B

4. Quick Check:

   Use borrow_mut() to mutate RefCell value [OK]

Hint: Use *borrow_mut() to change RefCell's inner value [OK]

Common Mistakes:

• Trying to assign a new RefCell instead of mutating inside
• Using borrow() instead of borrow_mut() for mutation
• Trying to add directly to RefCell without borrowing