update Rustonomicon link

[rust-101.git] / src / part05.rs

diff --git a/src/part05.rs b/src/part05.rs
index 7324d13361111109ab482ee3b82d43051b7ee5b4..6d2d813144cdb8f239352bd9053a3c2c9c4d286d 100644 (file)
--- a/src/part05.rs
+++ b/src/part05.rs
@@ -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