interior-mutability

The Rust documentation covers Rc<RefCell<T>> pretty extensively but doesn't go into RefCell<Rc<T>> , which I am now encountering. Do these effectively give the same result? Is there an important difference between them? Do these effectively give the same result? They are very different. Rc is a pointer with shared ownership while RefCell provides interior mutability. The order in which they are composed makes a big difference to how they can be used. Usually, you compose them as Rc<RefCell<T>> ; the whole thing is shared and each shared owner gets to mutate the contents. The effect of mutating

When would you be required to use Cell or RefCell ? It seems like there are many other type choices that would be suitable in place of these, and the documentation warns that using RefCell is a bit of a "last resort". Is using these types a " code smell "? Can anyone show an example where using these types makes more sense than using another type, such as Rc or even Box ? Vladimir Matveev It is not entirely correct to ask when Cell or RefCell should be used over Box and Rc because these types solve different problems. Indeed, more often than not RefCell is used together with Rc in order to

This question already has an answer here: How do I return a reference to something inside a RefCell without breaking encapsulation? 3 answers I have a RefCell<HashMap> and want to borrow the table, find a key, and return a reference to the result: use std::cell::RefCell; use std::collections::HashMap; struct Frame { map: RefCell<HashMap<String, String>>, } impl Frame { fn new() -> Frame { Frame { map: RefCell::new(HashMap::new()), } } fn lookup<'a>(&'a self, k: &String) -> Option<&'a String> { self.map.borrow().get(k) } } fn main() { let f = Frame::new(); println!("{}", f.lookup(&"hello".to

I have a struct that has inner mutability. use std::cell::RefCell; struct MutableInterior { hide_me: i32, vec: Vec<i32>, } struct Foo { //although not used in this particular snippet, //the motivating problem uses interior mutability //via RefCell. interior: RefCell<MutableInterior>, } impl Foo { pub fn get_items(&self) -> &Vec<i32> { &self.interior.borrow().vec } } fn main() { let f = Foo { interior: RefCell::new(MutableInterior { vec: Vec::new(), hide_me: 2, }), }; let borrowed_f = &f; let items = borrowed_f.get_items(); } Produces the error: error[E0597]: borrowed value does not live long