From 39b387735112972cad7bb3175393a0a09d767335 Mon Sep 17 00:00:00 2001 From: Ralf Jung Date: Fri, 10 Jul 2015 15:51:34 +0200 Subject: [PATCH 1/1] part11: first version --- src/main.rs | 1 + src/part10.rs | 13 ++-- src/part11.rs | 141 ++++++++++++++++++++++++++++++++++++++++ workspace/src/main.rs | 2 + workspace/src/part10.rs | 11 ++-- workspace/src/part11.rs | 99 ++++++++++++++++++++++++++++ 6 files changed, 254 insertions(+), 13 deletions(-) create mode 100644 src/part11.rs create mode 100644 workspace/src/part11.rs diff --git a/src/main.rs b/src/main.rs index 68578fd..35c670f 100644 --- a/src/main.rs +++ b/src/main.rs @@ -91,6 +91,7 @@ mod part07; 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. diff --git a/src/part10.rs b/src/part10.rs index 452e993..cfa10e4 100644 --- a/src/part10.rs +++ b/src/part10.rs @@ -1,8 +1,7 @@ // 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`. @@ -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 { - 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) { - println!("{}{}", self.prefix, digit); + println!("{}{}", self.prefix, digit); /*@*/ } } @@ -73,7 +72,7 @@ impl BigInt { fn act(&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, divisor: i32) -> Vec { //@ 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 @@ -142,4 +141,4 @@ fn filter_vec_by_divisor(v: &Vec, divisor: i32) -> Vec { // 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 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 { + callbacks: Vec, + } + //@ 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` 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, + } */ + //@ 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` is a lot like `T`: You fully own + //@ the data stored there. On the machine, however, `Box` 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` itself will always be sized. So we can put it in a `Vec`. + struct Callbacks { + callbacks: Vec>, + } + + 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) { + 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`. 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>, + } + + // 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) { + 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 4d6d230..8531db6 100644 --- a/workspace/src/main.rs +++ b/workspace/src/main.rs @@ -11,6 +11,8 @@ mod part06; mod part07; mod part08; mod part09; +mod part10; +mod part11; // This decides which part is actually run. fn main() { diff --git a/workspace/src/part10.rs b/workspace/src/part10.rs index 7af1617..3af444f 100644 --- a/workspace/src/part10.rs +++ b/workspace/src/part10.rs @@ -1,8 +1,7 @@ // Rust-101, Part 10: Closures // =========================== -use std::io::prelude::*; -use std::{fmt,io}; +use std::fmt; use part05::BigInt; @@ -15,7 +14,7 @@ trait Action { impl BigInt { fn act_v1(&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) { - println!("{}{}", self.prefix, digit); + unimplemented!() } } @@ -52,7 +51,7 @@ impl BigInt { fn act(&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(v: &Vec) { // 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, divisor: i32) -> Vec { - 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 diff --git a/workspace/src/part11.rs b/workspace/src/part11.rs new file mode 100644 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 { + callbacks: Vec, + } + + /* struct CallbacksV2 { + callbacks: Vec, + } */ + + struct Callbacks { + callbacks: Vec>, + } + + 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) { + 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>, + } + + // 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) { + 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. + -- 2.30.2