RefCell overview in Rust - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a new RefCell containing the value 5.

Rust

let value = std::cell::[1]::new(5);

Drag options to blanks, or click blank then click option'

ARefCell

BCell

CMutex

DRc

Attempts:

3 left

💡 Hint

Common Mistakes

Using Cell instead of RefCell, which has different borrowing rules.

Using Rc which is for reference counting, not interior mutability.

The RefCell type allows mutable borrowing checked at runtime. Here, RefCell::new(5) creates a new RefCell holding the value 5.

2fill in blank

medium

Complete the code to borrow the value immutably from the RefCell.

Rust

let value = std::cell::RefCell::new(10);
let borrowed = value.[1]();

Drag options to blanks, or click blank then click option'

Aborrow_mut

Bborrow

Cget

Dclone

Attempts:

3 left

💡 Hint

Common Mistakes

Using borrow_mut() when only an immutable borrow is needed.

Trying to use get(), which is not a method of RefCell.

The borrow() method immutably borrows the value inside the RefCell. It returns a smart pointer that enforces borrowing rules at runtime.

3fill in blank

hard

Fix the error in the code to mutably borrow the value inside the RefCell.

Rust

let cell = std::cell::RefCell::new(20);
let mut_ref = cell.[1]();

Drag options to blanks, or click blank then click option'

Aborrow_mut

Bborrow

Cget_mut

Dclone

Attempts:

3 left

💡 Hint

Common Mistakes

Using borrow() instead of borrow_mut() for mutable access.

Trying to use get_mut(), which is not available on RefCell.

The borrow_mut() method mutably borrows the value inside the RefCell. Using borrow() would only give an immutable borrow and cause a compile-time or runtime error if mutable access is needed.

4fill in blank

hard

Fill both blanks to create a RefCell, mutably borrow its value, and change it.

Rust

let cell = std::cell::[1]::new(30);
let mut val = cell.[2]();
*val = 40;

Drag options to blanks, or click blank then click option'

ARefCell

Bborrow

Cborrow_mut

DCell

Attempts:

3 left

💡 Hint

Common Mistakes

Using Cell instead of RefCell, which has different borrowing rules.

Using borrow() instead of borrow_mut() when trying to mutate.

First, create a RefCell with RefCell::new(30). Then, mutably borrow the value with borrow_mut() to change it.

5fill in blank

hard

Fill all three blanks to create a RefCell, borrow it immutably, and print the value.

Rust

let cell = std::cell::[1]::new(50);
let val = cell.[2]();
println!("Value is: {}", *[3]);

Drag options to blanks, or click blank then click option'

ACell

Bborrow

Cval

DRefCell

Attempts:

3 left

💡 Hint

Common Mistakes

Using Cell instead of RefCell.

Trying to print the RefCell itself instead of the borrowed value.

Create a RefCell with RefCell::new(50). Then immutably borrow it with borrow(). Finally, dereference val to print the inner value.

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