X-Git-Url: https://git.ralfj.de/rust-101.git/blobdiff_plain/4f61be32dd480f23a7fef05ee66c42ae27c980c6..b30edaca267b5900279eb43b5a70889899bad62d:/src/part05.rs
diff --git a/src/part05.rs b/src/part05.rs
index 72c787d..6d2d813 100644
--- a/src/part05.rs
+++ b/src/part05.rs
@@ -10,7 +10,7 @@
//@ to use a vector "digits" of the number. This is like "1337" being a vector of four digits (1, 3, 3, 7),
//@ except that we will use `u64` as type of our digits, meaning we have 2^64 individual digits. Now we just
//@ have to decide the order in which we store numbers. I decided that we will store the least significant
-//@ digit first. This means that "1337" would actually become (7, 3, 3, 1).
+//@ digit first. This means that "1337" would actually become (7, 3, 3, 1).
//@ Finally, we declare that there must not be any trailing zeros (corresponding to
//@ useless leading zeros in our usual way of writing numbers). This is to ensure that
//@ the same number can only be stored in one way.
@@ -21,7 +21,7 @@
//@ `data` public - otherwise, the next parts of this course could not work on `BigInt`s. Of course, in a
//@ real program, one would make the field private to ensure that the invariant (no trailing zeros) is maintained.
pub struct BigInt {
- pub data: Vec,
+ pub data: Vec, // least significant digit first, no trailing zeros
}
// Now that we fixed the data representation, we can start implementing methods on it.
@@ -31,7 +31,7 @@ impl BigInt {
//@ fields and initial values assigned to them.
pub fn new(x: u64) -> Self {
if x == 0 {
- BigInt { data: vec![] }
+ BigInt { data: vec![] } /*@*/
} else {
BigInt { data: vec![x] } /*@*/
}
@@ -48,12 +48,14 @@ impl BigInt {
}
// We can convert any vector of digits into a number, by removing trailing zeros. The `mut`
- // declaration for `v` here is just like the one in `let mut ...`, it says that we will locally
- // change the vector `v`.
+ // declaration for `v` here is just like the one in `let mut ...`: We completely own `v`, but Rust
+ // still asks us to make our intention of modifying it explicit. This `mut` is *not* part of the
+ // type of `from_vec` - the caller has to give up ownership of `v` anyway, so they don't care anymore
+ // what you do to it.
//
// **Exercise 05.1**: Implement this function.
//
- // *Hint*: You can use `pop()` to remove the last element of a vector.
+ // *Hint*: You can use `pop` to remove the last element of a vector.
pub fn from_vec(mut v: Vec) -> Self {
unimplemented!()
}
@@ -111,7 +113,7 @@ impl Clone for SomethingOrNothing {
//@ `#[derive(Clone)]` right before the definition of `SomethingOrNothing`.
// **Exercise 05.2**: Write some more functions on `BigInt`. What about a function that returns the number of
-// digits? The number of non-zero digits? The smallest/largest digit?
+// digits? The number of non-zero digits? The smallest/largest digit? Of course, these should all just borrow `self`.
// ## Mutation + aliasing considered harmful (part 2)
//@ Now that we know how to borrow a part of an `enum` (like `v` above), there's another example for why we
@@ -131,7 +133,7 @@ fn work_on_variant(mut var: Variant, text: String) {
Variant::Number(ref mut n) => ptr = n,
Variant::Text(_) => return,
}
- /* var = Variant::Text(text); */
+ /* var = Variant::Text(text); */ /* BAD! */
*ptr = 1337;
}
//@ Now, imagine what would happen if we were permitted to also mutate `var`. We could, for example,