split part 11 into two, and explain interior mutability and Cell and RefCell in the...
[rust-101.git] / workspace / src / part12.rs
1 // Rust-101, Part 12: Rc, Interior Mutability, Cell, RefCell
2 // =========================================================
3
4 use std::rc::Rc;
5 use std::cell::{Cell, RefCell};
6
7
8
9 #[derive(Clone)]
10 struct Callbacks {
11     callbacks: Vec<Rc<Fn(i32)>>,
12 }
13
14 impl Callbacks {
15     pub fn new() -> Self {
16         unimplemented!()
17     }
18
19     // Registration works just like last time, except that we are creating an `Rc` now.
20     pub fn register<F: Fn(i32)+'static>(&mut self, callback: F) {
21         unimplemented!()
22     }
23
24     pub fn call(&self, val: i32) {
25         // We only need a shared iterator here. Since `Rc` is a smart pointer, we can directly call the callback.
26         for callback in self.callbacks.iter() {
27             unimplemented!()
28         }
29     }
30 }
31
32 // Time for a demo!
33 fn demo(c: &mut Callbacks) {
34     c.register(|val| println!("Callback 1: {}", val));
35     c.call(0); c.clone().call(1);
36 }
37
38 pub fn main() {
39     let mut c = Callbacks::new();
40     demo(&mut c);
41 }
42
43 // ## Interior Mutability
44
45 // So, let us put our counter in a `Cell`, and replicate the example from the previous part.
46 fn demo_cell(c: &mut Callbacks) {
47     {
48         let count = Cell::new(0);
49         // Again, we have to move ownership if the `count` into the environment closure.
50         c.register(move |val| {
51             // In here, all we have is a shared borrow of our environment. But that's good enough for the `get` and `set` of the cell!
52             let new_count = count.get()+1;
53             count.set(new_count);
54             println!("Callback 2: {} ({}. time)", val, new_count);
55         } );
56     }
57
58     c.call(2); c.clone().call(3);
59 }
60
61
62 // ## `RefCell`
63
64 // Our final version of `Callbacks` puts the closure environment into a `RefCell`.
65 #[derive(Clone)]
66 struct CallbacksMut {
67     callbacks: Vec<Rc<RefCell<FnMut(i32)>>>,
68 }
69
70 impl CallbacksMut {
71     pub fn new() -> Self {
72         unimplemented!()
73     }
74
75     pub fn register<F: FnMut(i32)+'static>(&mut self, callback: F) {
76         let cell = Rc::new(RefCell::new(callback));
77         unimplemented!()
78     }
79
80     pub fn call(&mut self, val: i32) {
81         for callback in self.callbacks.iter() {
82             // We have to *explicitly* borrow the contents of a `RefCell` by calling `borrow` or `borrow_mut`.
83             let mut closure = callback.borrow_mut();
84             // Unfortunately, Rust's auto-dereference of pointers is not clever enough here. We thus have to explicitly
85             // dereference the smart pointer and obtain a mutable borrow of the content.
86             (&mut *closure)(val);
87         }
88     }
89 }
90
91 // Now we can repeat the demo from the previous part - but this time, our `CallbacksMut` type
92 // can be cloned.
93 fn demo_mut(c: &mut CallbacksMut) {
94     c.register(|val| println!("Callback 1: {}", val));
95     c.call(0);
96
97     {
98         let mut count: usize = 0;
99         c.register(move |val| {
100             count = count+1;
101             println!("Callback 2: {} ({}. time)", val, count);
102         } );
103     }
104     c.call(1); c.clone().call(2);
105 }
106
107 // **Exercise 12.1**: Change the type of `call` to ask only for a shared borrow. Then write some piece of code using only the available, public
108 // interface of `CallbacksMut` such that a reentrant call to `call` is happening, and the program aborts because the `RefCell` refuses to hand
109 // out a second mutable borrow to its content.
110