X-Git-Url: https://git.ralfj.de/rust-101.git/blobdiff_plain/4f61be32dd480f23a7fef05ee66c42ae27c980c6..f9c259224010e06892dd3cc91b654965da04e0d2:/src/part05.rs?ds=inline

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).<br/>
+//@ digit first. This means that "1337" would actually become (7, 3, 3, 1). <br/>
 //@ 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<u64>,
+    pub data: Vec<u64>, // 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<u64>) -> Self {
         unimplemented!()
     }
@@ -111,7 +113,7 @@ impl<T: Clone> Clone for SomethingOrNothing<T> {
 //@ `#[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,