part11: first version

diff --git a/src/main.rs b/src/main.rs
index 68578fdb59987d60344f8b5d138eab1a7f5cad2a..35c670fd1b549ac435e960291e12bf938e1db0b0 100644 (file)
--- a/src/main.rs
+++ b/src/main.rs
@@ -91,6 +91,7 @@ mod part07;
 mod part08;
 mod part09;
 mod part10;
 mod part08;
 mod part09;
 mod part10;

+mod part11;

 
 // To actually run the code of some part (after filling in the blanks, if necessary), simply edit the `main`
 // function.
 
 // To actually run the code of some part (after filling in the blanks, if necessary), simply edit the `main`
 // function.

diff --git a/src/part10.rs b/src/part10.rs
index 452e993d36a63e35c8abd38b72cdbe0e68fc1fa6..cfa10e43213869052ea2260f341bff3f290b77f0 100644 (file)
--- a/src/part10.rs
+++ b/src/part10.rs
@@ -1,8 +1,7 @@
 // Rust-101, Part 10: Closures
 // ===========================
 
 // Rust-101, Part 10: Closures
 // ===========================
 

-use std::io::prelude::*;
-use std::{fmt,io};
+use std::fmt;

 use part05::BigInt;
 
 //@ Assume we want to write a function that does *something* on, say, every digit of a `BigInt`.
 use part05::BigInt;
 
 //@ Assume we want to write a function that does *something* on, say, every digit of a `BigInt`.


@@ -24,7 +23,7 @@ impl BigInt {
         //@ Remember that the `mut` above is just an annotation to Rust, telling it that we're okay with `a` being mutated.
         //@ Calling `do_action` on `a` takes a mutable borrow, so mutation could indeed happen.
         for digit in self {
         //@ Remember that the `mut` above is just an annotation to Rust, telling it that we're okay with `a` being mutated.
         //@ Calling `do_action` on `a` takes a mutable borrow, so mutation could indeed happen.
         for digit in self {

-            a.do_action(digit);
+            a.do_action(digit);                                     /*@*/

         }
     }
 }
         }
     }
 }


@@ -40,7 +39,7 @@ impl Action for PrintWithString {
     // Here we perform performs the actual printing of the prefix and the digit. We're not making use of our ability to
     // change `self` here, but we could replace the prefix if we wanted.
     fn do_action(&mut self, digit: u64) {
     // Here we perform performs the actual printing of the prefix and the digit. We're not making use of our ability to
     // change `self` here, but we could replace the prefix if we wanted.
     fn do_action(&mut self, digit: u64) {

-        println!("{}{}", self.prefix, digit);
+        println!("{}{}", self.prefix, digit);                       /*@*/

     }
 }
 
     }
 }
 


@@ -73,7 +72,7 @@ impl BigInt {
     fn act<A: FnMut(u64)>(&self, mut a: A) {
         for digit in self {
             // We can call closures as if they were functions - but really, what's happening here is translated to essentially what we wrote above, in `act_v1`.
     fn act<A: FnMut(u64)>(&self, mut a: A) {
         for digit in self {
             // We can call closures as if they were functions - but really, what's happening here is translated to essentially what we wrote above, in `act_v1`.

-            a(digit);
+            a(digit);                                               /*@*/

         }
     }
 }
         }
     }
 }


@@ -134,7 +133,7 @@ fn filter_vec_by_divisor(v: &Vec<i32>, divisor: i32) -> Vec<i32> {
     //@ Here, the return type of `collect` is inferred based on the return type of our function. In general, it can return anything implementing
     //@ [`FromIterator`](http://doc.rust-lang.org/stable/std/iter/trait.FromIterator.html). Notice that `iter` gives us an iterator over
     //@ borrowed `i32`, but we want to own them for the result, so we insert a `map` to dereference.
     //@ Here, the return type of `collect` is inferred based on the return type of our function. In general, it can return anything implementing
     //@ [`FromIterator`](http://doc.rust-lang.org/stable/std/iter/trait.FromIterator.html). Notice that `iter` gives us an iterator over
     //@ borrowed `i32`, but we want to own them for the result, so we insert a `map` to dereference.

-    v.iter().map(|n| *n).filter(|n| *n % divisor == 0).collect()
+    v.iter().map(|n| *n).filter(|n| *n % divisor == 0).collect()    /*@*/

 }
 
 // **Exercise 10.1**: Look up the [documentation of `Iterator`](http://doc.rust-lang.org/stable/std/iter/trait.Iterator.html) to learn about more functions
 }
 
 // **Exercise 10.1**: Look up the [documentation of `Iterator`](http://doc.rust-lang.org/stable/std/iter/trait.Iterator.html) to learn about more functions


@@ -142,4 +141,4 @@ fn filter_vec_by_divisor(v: &Vec<i32>, divisor: i32) -> Vec<i32> {
 // product of those numbers that sit at odd positions? A function that checks whether a vector contains a certain number? Whether all numbers are
 // smaller than some threshold? Be creative!
 
 // product of those numbers that sit at odd positions? A function that checks whether a vector contains a certain number? Whether all numbers are
 // smaller than some threshold? Be creative!
 

-//@ [index](main.html) | [previous](part08.html) | [next](main.html)
+//@ [index](main.html) | [previous](part09.html) | [next](main.html)

diff --git a/src/part11.rs b/src/part11.rs
new file mode 100644 (file)
index 0000000..1256e19
--- /dev/null
+++ b/src/part11.rs
@@ -0,0 +1,141 @@
+// Rust-101, Part 11: Trait Objects, Box (WIP)
+// ===========================================
+
+//@ Now that we know about closures, let's have some fun with them. We will try to implement some kind of generic "callback"
+//@ mechanism, providing two functions: Registering a new callback, and calling all registered callbacks. There will be two
+//@ versions, so to avoid clashes of names, we put them into modules.
+
+mod callbacks {
+    //@ First of all, we need to find a way to store the callbacks. Clearly, there will be a `Vec` involves, so that we can
+    //@ always grow the number of registered callbacks. A callback will be a closure, i.e., something implementing
+    //@ `FnMut(i32)` (we want to call this multiple times, so clearly `FnOnce` would be no good). So our first attempt may be the following.
+    // For now, we just decide that the callbakcs have an argument of type `i32`.
+    struct CallbacksV1<F: FnMut(i32)> {
+        callbacks: Vec<F>,
+    }
+    //@ However, this will not work. Remember how the "type" of a closure is specific to the environment of captures variables. Different closures
+    //@ all implementing `FnMut(i32)` may be different types. However, a `Vec<F>` is a *uniformly typed* vector.
+
+    //@ We will this need a way to store things of *different* types in the same vector. We know all these types implement `FnMut(i32)`. For this scenario,
+    //@ Rust provides *trait objects*: The truth is, that `FnMut(i32)` is not just a trait. It is also a type, that can be given to anything implementing
+    //@ this trait. So, we may write:
+    /* struct CallbacksV2 {
+        callbacks: Vec<FnMut(i32)>,
+    } */
+    //@ But, Rust complains about this definition. It says something about "Sized". What's the trouble? See, for many things we want to do, it is crucial that
+    //@ Rust knows the precise, fixed size of the type - that is, how large will this type be when represented in memory. For example, for a `Vec`, the
+    //@ elements are stored one right after the other. How should that be possible, without a fixed size? The trouble is, `FnMut(i32)` could be of any size.
+    //@ We don't know how large that "type that implemenets `FnMut(i32)`" is. Rust calls this an *unsized* type. Whenever we introduce a type variable, Rust
+    //@ will implicitly add a bound to that variable, demanding that it is sized. That's why we did not have to worry about this so far.
+    //@ You can, btw, opt-out of this implicit bound by saying `T: ?Sized`. Then `T` may or may not be sized.
+
+    //@ So, what can we do, if we can't store the callbacks in a vector? We can put them in a box. Semantically, `Box<T>` is a lot like `T`: You fully own
+    //@ the data stored there. On the machine, however, `Box<T>` is a *pointer* to `T`. It is a lot like `std::unique_ptr` in C++. In our current example,
+    //@ the important bit is that since it's a pointer, `T` can be unsized, but `Box<T>` itself will always be sized. So we can put it in a `Vec`.
+    struct Callbacks {
+        callbacks: Vec<Box<FnMut(i32)>>,
+    }
+
+    impl Callbacks {
+        // Now we can provide some functions. The constructor should be straight-forward.
+        fn new() -> Self {
+            Callbacks { callbacks: Vec::new() }                     /*@*/
+        }
+
+        // Registration simply stores the callback.
+        fn register(&mut self, callback: Box<FnMut(i32)>) {
+            self.callbacks.push(callback);                          /*@*/
+        }
+
+        // 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() {
+                callback(val);                                      /*@*/
+            }
+        }
+    }
+
+    // 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);
+
+        //@ We can even register callbacks that modify their environment. Rust will again attempt to borrow `count`. However,
+        //@ that doesn't work out this time: Since we want to put this thing in a `Box`, it could live longer than the function
+        //@ we are in. Then the borrow of `count` would become invalid. However, we can tell rust to `move` ownership of the
+        //@ variable into the closure. Its environment will then contain an `usize` rather than a `&mut uszie`, and have
+        //@ no effect on this local variable anymore.
+        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);
+    }
+
+}
+
+// Remember to edit `main.rs` to run the demo.
+pub fn main() {
+    callbacks::demo();
+}
+
+mod callbacks_clone {
+    //@ So, this worked great, didn't it! There's one point though that I'd like to emphasize: One cannot `clone` a closure.
+    //@ Hence it becomes impossibly to implement `Clone` for our `Callbacks` type. What could we do about this?
+
+    //@ You already learned about `Box` above. `Box` is historically a very special type in Rust (though it lost most of its
+    //@ particularities by now, and people are working on making it just a normal library type). Effectively, however, it is
+    //@ just an example of a *smart pointer*: It's like a pointer (i.e., a borrow), but with some additional smarts to it. For
+    //@ `Box`, that's the part about ownership. Once you drop the box, the content it points to will also be deleted.
+    //@ 
+    //@ Another example of a smart pointer in Rust is `Rc<T>`. This is short for *reference-counter*, so you can already guess how
+    //@ this pointer is smart: It has a reference count. You can `clone` an `Rc` as often as you want, that doesn't affect the
+    //@ data it contains at all. It only creates more references to the same data. Once all the references are gone, the data is
+    //@ deleted.
+    //@ 
+    //@ Wait a moment, you may here. Multiple references to the same data? That's aliasing! Indeed, we have to be careful here.
+    //@ Once data is stored in an `Rc`, is is read-only: By dereferencing the smart `Rc`, you can only get a shared borrow of the data.
+    use std::rc;
+
+    //@ Because of this read-only restriction, we cannot use `FnMut` here: We'd be unable to call the function with a mutable borrow
+    //@ of it's environment! So we have to go with `Fn`. We wrap that in an `Rc`, and then Rust happily derives `Clone` for us.
+    #[derive(Clone)]
+    struct Callbacks {
+        callbacks: Vec<rc::Rc<Fn(i32)>>,
+    }
+
+    // The methods on these clonable callbacks are just like the ones above.
+    impl Callbacks {
+        fn new() -> Self {
+            Callbacks { callbacks: Vec::new() }                     /*@*/
+        }
+
+        fn register(&mut self, callback: rc::Rc<Fn(i32)>) {
+            self.callbacks.push(callback);                          /*@*/
+        }
+
+        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() {
+                callback(val);                                      /*@*/
+            }
+        }
+    }
+
+    // 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)));
+
+        c.call(0);
+        c.call(1);
+    }
+}
+
+// **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
+// same `t: T`, you will either have to restrict `T` to `Copy` types, or pass a borrow.
+
+//@ [index](main.html) | [previous](part10.html) | [next](main.html)

diff --git a/workspace/src/main.rs b/workspace/src/main.rs
index 4d6d2302672ecab5aacac82de2010982988ae6b0..8531db62abfb3f0a509e2701789db1df4353a7cf 100644 (file)
--- a/workspace/src/main.rs
+++ b/workspace/src/main.rs
@@ -11,6 +11,8 @@ mod part06;
 mod part07;
 mod part08;
 mod part09;
 mod part07;
 mod part08;
 mod part09;

+mod part10;
+mod part11;

 
 // This decides which part is actually run.
 fn main() {
 
 // This decides which part is actually run.
 fn main() {

diff --git a/workspace/src/part10.rs b/workspace/src/part10.rs
index 7af161716f6a07971f499351081defbef299100f..3af444faa7a3ca3d3f99642fd7436d40c9cadf26 100644 (file)
--- a/workspace/src/part10.rs
+++ b/workspace/src/part10.rs
@@ -1,8 +1,7 @@
 // Rust-101, Part 10: Closures
 // ===========================
 
 // Rust-101, Part 10: Closures
 // ===========================
 

-use std::io::prelude::*;
-use std::{fmt,io};
+use std::fmt;

 use part05::BigInt;
 
 
 use part05::BigInt;
 
 


@@ -15,7 +14,7 @@ trait Action {
 impl BigInt {
     fn act_v1<A: Action>(&self, mut a: A) {
         for digit in self {
 impl BigInt {
     fn act_v1<A: Action>(&self, mut a: A) {
         for digit in self {

-            a.do_action(digit);
+            unimplemented!()

         }
     }
 }
         }
     }
 }


@@ -28,7 +27,7 @@ impl Action for PrintWithString {
     // Here we perform performs the actual printing of the prefix and the digit. We're not making use of our ability to
     // change `self` here, but we could replace the prefix if we wanted.
     fn do_action(&mut self, digit: u64) {
     // Here we perform performs the actual printing of the prefix and the digit. We're not making use of our ability to
     // change `self` here, but we could replace the prefix if we wanted.
     fn do_action(&mut self, digit: u64) {

-        println!("{}{}", self.prefix, digit);
+        unimplemented!()

     }
 }
 
     }
 }
 


@@ -52,7 +51,7 @@ impl BigInt {
     fn act<A: FnMut(u64)>(&self, mut a: A) {
         for digit in self {
             // We can call closures as if they were functions - but really, what's happening here is translated to essentially what we wrote above, in `act_v1`.
     fn act<A: FnMut(u64)>(&self, mut a: A) {
         for digit in self {
             // We can call closures as if they were functions - but really, what's happening here is translated to essentially what we wrote above, in `act_v1`.

-            a(digit);
+            unimplemented!()

         }
     }
 }
         }
     }
 }


@@ -90,7 +89,7 @@ fn print_enumerated<T: fmt::Display>(v: &Vec<T>) {
 
 // And as a final example, one can also collect all elements of an iterator, and put them, e.g., in a vector.
 fn filter_vec_by_divisor(v: &Vec<i32>, divisor: i32) -> Vec<i32> {
 
 // And as a final example, one can also collect all elements of an iterator, and put them, e.g., in a vector.
 fn filter_vec_by_divisor(v: &Vec<i32>, divisor: i32) -> Vec<i32> {

-    v.iter().map(|n| *n).filter(|n| *n % divisor == 0).collect()
+    unimplemented!()

 }
 
 // **Exercise 10.1**: Look up the [documentation of `Iterator`](http://doc.rust-lang.org/stable/std/iter/trait.Iterator.html) to learn about more functions
 }
 
 // **Exercise 10.1**: Look up the [documentation of `Iterator`](http://doc.rust-lang.org/stable/std/iter/trait.Iterator.html) to learn about more functions

diff --git a/workspace/src/part11.rs b/workspace/src/part11.rs
new file mode 100644 (file)
index 0000000..f868a3c
--- /dev/null
+++ b/workspace/src/part11.rs
@@ -0,0 +1,99 @@
+// Rust-101, Part 11: Trait Objects, Box (WIP)
+// ===========================================
+
+
+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)>>,
+    }
+
+    impl Callbacks {
+        // Now we can provide some functions. The constructor should be straight-forward.
+        fn new() -> Self {
+            unimplemented!()
+        }
+
+        // Registration simply stores the callback.
+        fn register(&mut self, callback: Box<FnMut(i32)>) {
+            unimplemented!()
+        }
+
+        // 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!()
+            }
+        }
+    }
+
+    // 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);
+    }
+
+}
+
+// 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)>>,
+    }
+
+    // The methods on these clonable callbacks are just like the ones above.
+    impl Callbacks {
+        fn new() -> Self {
+            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)));
+
+        c.call(0);
+        c.call(1);
+    }
+}
+
+// **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
+// same `t: T`, you will either have to restrict `T` to `Copy` types, or pass a borrow.
+