Implementing a Basic RefCell in Rust

RefCell is a powerful tool in Rust for working with interior mutability, allowing you to modify data even when you only have an immutable reference. This challenge asks you to implement a simplified version of RefCell to understand the underlying mechanisms of interior mutability and borrowing in Rust. Successfully completing this challenge will deepen your understanding of Rust's ownership and borrowing system.

Problem Description

You are tasked with implementing a basic RefCell structure in Rust. This RefCell should provide methods for borrowing and mutating a contained value. The core functionality revolves around allowing multiple immutable borrows or a single mutable borrow at any given time, adhering to Rust's borrowing rules. Your implementation should panic if borrowing rules are violated (e.g., attempting a mutable borrow while an immutable borrow exists).

Specifically, you need to implement the following:

• RefCell<T> struct: This struct will hold a reference to a value of type T.
• borrow(&self) -> Ref<T>: Returns an immutable borrow of the contained value.
• borrow_mut(&self) -> RefMut<T>: Returns a mutable borrow of the contained value.
• Ref<T> struct: Represents an immutable borrow. It should provide access to the contained value via &T.
• RefMut<T> struct: Represents a mutable borrow. It should provide access to the contained value via &mut T.

Your implementation should use a simple state machine to track borrows. For simplicity, you don't need to handle lifetimes explicitly; assume all borrows are valid until explicitly dropped. The panic message should be descriptive, indicating the type of borrowing rule violation.

Examples

Example 1:

Input:
let ref_cell: RefCell<i32> = RefCell::new(5);
let borrow1 = ref_cell.borrow();
let borrow2 = ref_cell.borrow();

Output:
// No panic. borrow1.0 == 5, borrow2.0 == 5

Explanation: Two immutable borrows are allowed.

Example 2:

Input:
let ref_cell: RefCell<i32> = RefCell::new(5);
let mut_borrow = ref_cell.borrow_mut();
let borrow1 = ref_cell.borrow(); // This will panic

Output:
// Panic: Cannot borrow `ref_cell` as mutable because it is also borrowed as immutable.

Explanation: Attempting an immutable borrow while a mutable borrow exists violates the borrowing rules.

Example 3:

Input:
let ref_cell: RefCell<i32> = RefCell::new(5);
let mut_borrow1 = ref_cell.borrow_mut();
mut_borrow1.change(10);
let mut_borrow2 = ref_cell.borrow_mut();
mut_borrow2.change(15);

Output:
// No panic.  The value is modified through the mutable borrows.

Explanation: Multiple mutable borrows are not allowed, but the example demonstrates that the value can be modified through a single mutable borrow. The change method is assumed to be part of the RefMut implementation.

Constraints

• The implementation should panic when borrowing rules are violated.
• The RefCell should be able to hold any type T.
• The Ref and RefMut structs should provide access to the contained value as expected.
• The code should be reasonably efficient (avoid unnecessary allocations or complex data structures).
• No external crates are allowed.

Notes

• Consider using a simple state variable (e.g., a boolean flag) to track whether a mutable borrow is active.
• The panic messages should be clear and informative, helping the user understand the borrowing rule that was violated.
• Focus on the core borrowing logic; error handling beyond panicking on borrowing rule violations is not required.
• The change method in Example 3 is a conceptual method. You don't need to implement it directly, but it illustrates the expected behavior of modifying the value through a mutable borrow. The RefMut struct should provide a way to modify the underlying value.
• This is a simplified implementation. A real RefCell would handle lifetimes and potentially more complex borrowing scenarios.