RefCell overview in Rust - Step-by-Step Execution

Concept Flow - RefCell overview

Create RefCell with value

↓

Borrow immutably?

No→Borrow mutably?

↓

Return Ref<T>

↓

Use value inside RefCell

↓

Borrow ends, Ref/RefMut dropped

↓

RefCell ready for next borrow

RefCell allows mutable borrowing checked at runtime, enabling multiple immutable or one mutable borrow inside single ownership.

Execution Sample

Rust

use std::cell::RefCell;

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

Creates a RefCell holding 5, borrows it immutably twice, then prints both values.

Execution Table

Step	Action	Borrow Type	Borrow Count (immutable, mutable)	Result	Output
1	Create RefCell with value 5	None	(0, 0)	RefCell created
2	Call borrow()	Immutable	(1, 0)	Returns Ref to 5
3	Call borrow() again	Immutable	(2, 0)	Returns another Ref to 5
4	Print values	Immutable	(2, 0)	Reads values 5 and 5	5 5
5	Refs go out of scope	None	(0, 0)	Borrows released

💡 All immutable borrows ended, RefCell ready for new borrows

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 5
data	RefCell(5)	RefCell(5)	RefCell(5)	RefCell(5)
r1	None	Ref(5)	Ref(5)	None
r2	None	None	Ref(5)	None

Key Moments - 3 Insights

Why can we call borrow() twice without error?

Because RefCell allows multiple immutable borrows at the same time, as shown in steps 2 and 3 where borrow count is (2, 0).

What happens if we try to borrow mutably while immutable borrows exist?

RefCell will panic at runtime because mutable borrow requires no other borrows, unlike the allowed multiple immutable borrows.

Why do r1 and r2 become None after step 5?

Because the Ref objects go out of scope, releasing the immutable borrows and resetting borrow counts to zero.

Visual Quiz - 3 Questions

Look at the execution table, what is the borrow count after step 3?

A (1, 1)

B (2, 0)

C (0, 1)

D (0, 0)

💡 Hint

Check the 'Borrow Count' column at step 3 in the execution_table.

At which step do the immutable borrows end?

A Step 5

B Step 4

C Step 3

D Step 2

💡 Hint

Look for when borrow count resets to (0, 0) in the execution_table.

If we tried a mutable borrow at step 3, what would happen?

A It would succeed and borrow count becomes (2,1)

B It would silently ignore the mutable borrow

C It would panic at runtime

D It would convert immutable borrows to mutable

💡 Hint

Recall RefCell rules: mutable borrow requires no other borrows; see key_moments about mutable borrow conflicts.

Concept Snapshot

RefCell<T> allows interior mutability checked at runtime.
Use borrow() for immutable access (multiple allowed).
Use borrow_mut() for mutable access (only one allowed).
Violations cause runtime panic.
Useful when you need mutability inside immutable structures.

Full Transcript

This visual trace shows how RefCell in Rust manages borrowing at runtime. We start by creating a RefCell holding the value 5. Then we borrow it immutably twice, increasing the immutable borrow count to 2. Both borrows return Ref objects that allow read access. We print the values, both 5, then the borrows end as the Ref objects go out of scope, resetting borrow counts. RefCell enforces borrowing rules at runtime: multiple immutable borrows allowed, but mutable borrow requires exclusive access. Attempting mutable borrow while immutable borrows exist causes panic. This helps safely mutate data inside otherwise immutable contexts.

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