{"@context":"https://schema.org","@type":"FAQPage","mainEntity":[{"@type":"Question","name":"What is the primary use case for Box in Rust?","acceptedAnswer":{"@type":"Answer","text":"Box allocates data on the heap instead of the stack. This is useful for types with unknown size at compile time (recursive types), transferring ownership of large data without copying, or creating trait objects. The Box pointer itself has a fixed size on the stack."}},{"@type":"Question","name":"How to define a recursive type like a linked list in Rust?","acceptedAnswer":{"@type":"Answer","text":"A direct recursive type like enum List { Cons(i32, List), Nil } does not compile because the compiler cannot determine the size. Using Box creates an indirection with a fixed size (pointer), allowing the compiler to calculate the type's size."}},{"@type":"Question","name":"What is the main difference between Rc and Arc?","acceptedAnswer":{"@type":"Answer","text":"Rc (Reference Counted) uses a non-atomic reference counter, making it more performant but limited to a single thread. Arc (Atomically Reference Counted) uses atomic operations for the counter, enabling sharing across threads but with a slight performance overhead."}},{"@type":"Question","name":"What does the Deref trait enable in Rust?","acceptedAnswer":{"@type":"Answer","text":"The Deref trait allows customizing the behavior of the dereference operator (*). It also enables deref coercion, allowing the compiler to automatically convert a reference to a type implementing Deref into a reference to the target type, such as &Box to &T."}},{"@type":"Question","name":"What is interior mutability in Rust?","acceptedAnswer":{"@type":"Answer","text":"Interior mutability is a design pattern that allows mutating data even when there are immutable references to that data. It uses types like RefCell or Cell that move borrow checking to runtime rather than compile time."}},{"@type":"Question","name":"What happens when attempting to mutably borrow a RefCell twice simultaneously?","acceptedAnswer":{"@type":"Answer","text":"RefCell enforces borrowing rules at runtime. If borrow_mut() is called twice without releasing the first borrow, the program panics. This is the cost of interior mutability: borrow errors become runtime errors rather than compile-time errors."}},{"@type":"Question","name":"How to create a new Rc instance that shares the same data as an existing instance?","acceptedAnswer":{"@type":"Answer","text":"The Rc::clone() method increments the reference counter and returns a new Rc pointing to the same data. Unlike a deep clone, this operation is inexpensive as it only copies the pointer and increments an integer counter."}},{"@type":"Question","name":"When is the Drop trait called for a value in Rust?","acceptedAnswer":{"@type":"Answer","text":"The Drop trait is automatically called by the compiler when a value goes out of scope. This allows releasing resources like heap memory, open files, or network connections. The drop order follows the reverse order of variable creation."}},{"@type":"Question","name":"How to force early release of a value before the end of its scope?","acceptedAnswer":{"@type":"Answer","text":"The std::mem::drop() function forces releasing a value before the end of its scope. This is useful for releasing resources like locks earlier than expected. You cannot call value.drop() directly because the compiler already calls it automatically."}},{"@type":"Question","name":"What is the problem with reference cycles using Rc?","acceptedAnswer":{"@type":"Answer","text":"Reference cycles with Rc create memory leaks. If A references B and B references A via Rc, the counters never reach zero even when no external variables reference these values. Memory is never freed because each element keeps the other alive."}},{"@type":"Question","name":"How to avoid reference cycles with Rc?","acceptedAnswer":{"@type":"Answer","text":"Weak is a non-owning version of Rc that does not increment the strong count. When all Rc references are freed, the value is destroyed even if Weak references remain. To access the value, call upgrade() which returns Option>."}},{"@type":"Question","name":"What is the difference between Cell and RefCell?","acceptedAnswer":{"@type":"Answer","text":"Cell works by copying: you can get() and set() the entire value but cannot obtain references. RefCell works by borrowing: you can obtain references (&T via borrow(), &mut T via borrow_mut()). Cell is lighter but limited to Copy types."}},{"@type":"Question","name":"How to combine Rc and RefCell for shared mutable access?","acceptedAnswer":{"@type":"Answer","text":"The Rc> pattern allows multiple owners (Rc) of mutable data (RefCell). Each owner can modify the value via borrow_mut(). This is a common pattern for graphs or trees with mutual parent/child references."}},{"@type":"Question","name":"What does the Weak::upgrade() method return?","acceptedAnswer":{"@type":"Answer","text":"Weak::upgrade() returns Option>. It returns Some(Rc) if the value still exists (strong count > 0), or None if the value has been freed. This is necessary because Weak does not guarantee the value still exists."}},{"@type":"Question","name":"Why does Rc not implement the Send trait?","acceptedAnswer":{"@type":"Answer","text":"Rc uses a non-atomic reference counter that is not thread-safe. If two threads modified the counter simultaneously, it would cause data races. Arc uses atomic operations for the counter and implements Send and Sync."}},{"@type":"Question","name":"What is deref coercion in Rust?","acceptedAnswer":{"@type":"Answer","text":"Deref coercion is an automatic conversion performed by the compiler on types implementing Deref. For example, &String to &str, or &Box to &T. This allows using &String wherever &str is expected without explicit conversion."}},{"@type":"Question","name":"What is the signature of the Deref trait?","acceptedAnswer":{"@type":"Answer","text":"The Deref trait defines an associated type Target and a deref() method that returns &Self::Target. This allows the * operator to convert &T to &Target. The DerefMut trait is similar but returns &mut Self::Target for mutable dereferences."}},{"@type":"Question","name":"How to get the number of strong references of an Rc?","acceptedAnswer":{"@type":"Answer","text":"Rc::strong_count(&rc) returns the number of strong references (Rc) pointing to the value. Rc::weak_count(&rc) returns the number of weak references (Weak). These functions are useful for debugging and understanding program behavior."}},{"@type":"Question","name":"When to use Arc> instead of Rc>?","acceptedAnswer":{"@type":"Answer","text":"Arc> is necessary for mutable sharing between threads. Arc provides thread-safe atomic counting, and Mutex provides mutual exclusion for mutability. Rc> is not thread-safe and can only be used in a single-threaded context."}},{"@type":"Question","name":"What happens if Drop is implemented for a type that also implements Copy?","acceptedAnswer":{"@type":"Answer","text":"This is impossible in Rust. Copy types are copied bit-by-bit and it would be ambiguous when to call drop(). If drop() were called on each copy, it would cause double-free. The compiler refuses to implement both traits on the same type."}},{"@type":"Question","name":"How to create a Weak from an Rc?","acceptedAnswer":{"@type":"Answer","text":"The Rc::downgrade(&rc) method creates a Weak from an Rc. This operation increments the weak count but not the strong count. The resulting Weak can be upgrade() later to attempt obtaining an Rc, returning None if the value has been freed."}},{"@type":"Question","name":"Which method to use to check if a RefCell borrow is possible without panic?","acceptedAnswer":{"@type":"Answer","text":"The try_borrow() and try_borrow_mut() methods return Result instead of panicking. They return Ok(Ref) or Ok(RefMut) if the borrow is valid, or Err(BorrowError) if the borrow would violate rules. This is useful when panic is not acceptable."}}]}