RefCell

RefCell is a type in Rust's standard library that provides interior mutability for single-threaded contexts. It allows you to mutate data even when there are immutable references to the same data, by performing all borrow checks at runtime rather than at compile time. This enables patterns where ownership is shared or where data needs to be mutated through shared references.

The core mechanism of RefCell is dynamic borrow checking. It tracks the number of active immutable borrows and whether a mutable borrow is currently in effect. You obtain borrows via borrow() for an immutable reference, which yields a Ref<T>, or borrow_mut() for a mutable reference, which yields a RefMut<T>. Both Ref and RefMut dereference to the inner value. When a borrow is dropped, the borrow count is updated accordingly. If you try to acquire a mutable borrow while any immutable borrow exists, or acquire any borrow while a mutable borrow exists, the program will panic at runtime. There are also fallible variants, try_borrow() and try_borrow_mut(), which return error values instead of panicking.

RefCell also provides into_inner() to extract the underlying value, but only when there are no outstanding borrows. This runtime-checked behavior distinguishes RefCell from compile-time borrowers like ordinary references.

Common usage patterns involve wrapping a shared, privately mutable value in Rc<RefCell<T>> to enable multiple owners to mutate the same data in a single-threaded context. However, RefCell is not thread-safe; it does not implement Send or Sync by default. For multi-threaded scenarios, types such as Arc<Mutex<T>> or Arc<RwLock<T>> are used instead.

In summary, RefCell enables interior mutability with runtime borrow checks, suitable for single-threaded scenarios where borrow rules must be enforced at runtime rather than by the compiler.