update the Cargo.lock files

[rust-101.git] / workspace / src / part11.rs

diff --git a/workspace/src/part11.rs b/workspace/src/part11.rs
index f868a3c05394548317b4f36e3bb71e863539efa0..a93ad07ed684bb301ac3d14b501f68cfe7713b97 100644 (file)
--- a/workspace/src/part11.rs
+++ b/workspace/src/part11.rs
@@ -1,99 +1,65 @@
-// Rust-101, Part 11: Trait Objects, Box (WIP)
-// ===========================================
+// Rust-101, Part 11: Trait Objects, Box, Lifetime bounds
+// ======================================================

 
 
 
 

-mod callbacks {
-    // For now, we just decide that the callbakcs have an argument of type `i32`.
-    struct CallbacksV1<F: FnMut(i32)> {
-        callbacks: Vec<F>,
-    }
-
-    /* struct CallbacksV2 {
-        callbacks: Vec<FnMut(i32)>,
-    } */
-
-    struct Callbacks {
-        callbacks: Vec<Box<FnMut(i32)>>,
-    }
+// For now, we just decide that the callbacks have an argument of type `i32`.
+struct CallbacksV1<F: FnMut(i32)> {
+    callbacks: Vec<F>,
+}

 
 

-    impl Callbacks {
-        // Now we can provide some functions. The constructor should be straight-forward.
-        fn new() -> Self {
-            unimplemented!()
-        }
+/* struct CallbacksV2 {
+    callbacks: Vec<FnMut(i32)>,
+} */

 
 

-        // Registration simply stores the callback.
-        fn register(&mut self, callback: Box<FnMut(i32)>) {
-            unimplemented!()
-        }
+pub struct Callbacks {
+    callbacks: Vec<Box<FnMut(i32)>>,
+}

 
 

-        // And here we call all the stored callbacks.
-        fn call(&mut self, val: i32) {
-            // Since they are of type `FnMut`, we need to mutably iterate. Notice that boxes dereference implicitly.
-            for callback in self.callbacks.iter_mut() {
-                unimplemented!()
-            }
-        }
+impl Callbacks {
+    // Now we can provide some functions. The constructor should be straight-forward.
+    pub fn new() -> Self {
+        unimplemented!()

     }
 
     }
 

-    // Now we are read for the demo.
-    pub fn demo() {
-        let mut c = Callbacks::new();
-        c.register(Box::new(|val| println!("Callback 1: {}", val)));
-
-        c.call(0);
-
-        let mut count: usize = 0;
-        c.register(Box::new(move |val| { count = count+1; println!("Callback 2, {}. time: {}", count, val); } ));
-        c.call(1);
-        c.call(2);
+    // Registration simply stores the callback.
+    pub fn register(&mut self, callback: Box<FnMut(i32)>) {
+        self.callbacks.push(callback);

     }
 
     }
 

-}
-
-// Remember to edit `main.rs` to run the demo.
-pub fn main() {
-    callbacks::demo();
-}
-
-mod callbacks_clone {
-
-    use std::rc;
-
-    #[derive(Clone)]
-    struct Callbacks {
-        callbacks: Vec<rc::Rc<Fn(i32)>>,
+    // We can also write a generic version of `register`, such that it will be instantiated with some concrete closure type `F`
+    // and do the creation of the `Box` and the conversion from `F` to `FnMut(i32)` itself.
+    
+    pub fn register_generic<F: FnMut(i32)+'static>(&mut self, callback: F) {
+        unimplemented!()

     }
 
     }
 

-    // The methods on these clonable callbacks are just like the ones above.
-    impl Callbacks {
-        fn new() -> Self {
+    // And here we call all the stored callbacks.
+    pub fn call(&mut self, val: i32) {
+        // Since they are of type `FnMut`, we need to mutably iterate.
+        for callback in self.callbacks.iter_mut() {

             unimplemented!()
         }
             unimplemented!()
         }

-
-        fn register(&mut self, callback: rc::Rc<Fn(i32)>) {
-            unimplemented!()
-        }
-
-        fn call(&mut self, val: i32) {
-            // We only need a shared iterator here. `Rc` also implicitly dereferences, so we can just call the callback.
-            for callback in self.callbacks.iter() {
-                unimplemented!()
-            }
-        }

     }
     }

+}

 
 

-    // The demo works just as above. Our counting callback doesn't work anymore though, because we are using `Fn` now.
-    fn demo() {
-        let mut c = Callbacks::new();
-        c.register(rc::Rc::new(|val| println!("Callback 1: {}", val)));
+// Now we are ready for the demo. Remember to edit `main.rs` to run it.
+pub fn main() {
+    let mut c = Callbacks::new();
+    c.register(Box::new(|val| println!("Callback 1: {}", val)));
+    c.call(0);

 
 

-        c.call(0);
-        c.call(1);
+    {
+        let mut count: usize = 0;
+        c.register_generic(move |val| {
+            count = count+1;
+            println!("Callback 2: {} ({}. time)", val, count);
+        } );

     }
     }

+    c.call(1); c.call(2);

 }
 
 }
 

-// **Exercise 11.1**: We made the arbitrary choice of using `i32` for the arguments. Generalize the data-structures above
+
+// **Exercise 11.1**: We made the arbitrary choice of using `i32` for the arguments. Generalize the data structures above

 // to work with an arbitrary type `T` that's passed to the callbacks. Since you need to call multiple callbacks with the
 // to work with an arbitrary type `T` that's passed to the callbacks. Since you need to call multiple callbacks with the

-// same `t: T`, you will either have to restrict `T` to `Copy` types, or pass a borrow.
+// same `t: T`, you will either have to restrict `T` to `Copy` types, or pass a reference.