Formatting

Fix a typo

.github/workflows/ci.yml

@@ -39,18 +39,6 @@ jobs:
         with:
           name: book
           path: book/book
-            # Commit and push all changed files.
-            # Must only affect files that are listed in "paths-ignore".
-      - name: Git commit build artifacts
-        # Only run on main branch push (e.g. pull request merge).
-        if: github.event_name == 'push'
-        run: |
-          git checkout -b deploy
-          git config --global user.name "Deployer"
-          git config --global user.email "username@users.noreply.github.com"
-          git add --force book/book
-          git commit -m "Render book"
-          git push --set-upstream --force-with-lease origin deploy
 
   formatter:
     runs-on: ubuntu-latest

Cargo.toml

@@ -2,5 +2,7 @@
 members = ["exercises/*/*", "helpers/common", "helpers/mdbook-exercise-linker", "helpers/ticket_fields"]
 resolver = "2"
 
-[profile.dev]
-overflow-checks = false
+# This is needed to guarantee the expected behaviour on that specific exercise,
+# regardless of the "global" setting for `overflow-checks` on the `dev` profile.
+[profile.dev.package.copy]
+overflow-checks = true

book/src/03_ticket_v1/03_modules.md

@@ -112,3 +112,10 @@ where each name comes from and potentially introducing name conflicts.\
 Nonetheless, it can be useful in some cases, like when writing unit tests. You might have noticed
 that most of our test modules start with a `use super::*;` statement to bring all the items from the parent module
 (the one being tested) into scope.
+
+## Visualizing the module tree
+
+If you're struggling to picture the module tree of your project, you can try using
+[`cargo-modules`](https://crates.io/crates/cargo-modules) to visualize it!
+
+Refer to their documentation for installation instructions and usage examples.

book/src/03_ticket_v1/05_encapsulation.md

@@ -23,7 +23,7 @@ To enforce stricter rules, we must keep the fields private[^newtype].
 We can then provide public methods to interact with a `Ticket` instance.
 Those public methods will have the responsibility of upholding our invariants (e.g. a title must not be empty).
 
-If all fields are private, it is no longer possible to create a `Ticket` instance directly using the struct
+If at least one field is private it is no longer possible to create a `Ticket` instance directly using the struct
 instantiation syntax:
 
 ```rust

book/src/04_traits/09_from.md

@@ -108,7 +108,7 @@ let title = String::from("A title");
 
 We've been primarily using `.into()`, though.\
 If you check out the [implementors of `Into`](https://doc.rust-lang.org/std/convert/trait.Into.html#implementors)
-you won't find `Into<&str> for String`. What's going on?
+you won't find `Into<String> for &str`. What's going on?
 
 `From` and `Into` are **dual traits**.\
 In particular, `Into` is implemented for any type that implements `From` using a **blanket implementation**:

book/src/05_ticket_v2/04_if_let.md

@@ -8,7 +8,7 @@ impl Ticket {
         match &self.status {
             Status::InProgress { assigned_to } => assigned_to,
             Status::Done | Status::ToDo => {
-                panic!("Only `In-Progress` tickets can be assigned to someone"),
+                panic!("Only `In-Progress` tickets can be assigned to someone")
             }
         }
     }

book/src/05_ticket_v2/10_packages.md

@@ -46,18 +46,3 @@ You can override these defaults by explicitly declaring your targets in the `Car
 [`cargo`'s documentation](https://doc.rust-lang.org/cargo/reference/cargo-targets.html#cargo-targets) for more details.
 
 Keep in mind that while a package can contain multiple crates, it can only contain one library crate.
-
-## Scaffolding a new package
-
-You can use `cargo` to scaffold a new package:
-
-```bash
-cargo new my-binary
-```
-
-This will create a new folder, `my-binary`, containing a new Rust package with the same name and a single
-binary crate inside. If you want to create a library crate instead, you can use the `--lib` flag:
-
-```bash
-cargo new my-library --lib
-```

book/src/07_threads/01_threads.md

@@ -6,7 +6,7 @@ and why we might want to use them.
 ## What is a thread?
 
 A **thread** is an execution context managed by the underlying operating system.\
-Each thread has its own stack, instruction pointer, and program counter.
+Each thread has its own stack and instruction pointer.
 
 A single **process** can manage multiple threads.
 These threads share the same memory space, which means they can access the same data.

book/src/07_threads/03_leak.md

@@ -27,12 +27,12 @@ run out and crash with an out-of-memory error.
 fn oom_trigger() {
     loop {
         let v: Vec<usize> = Vec::with_capacity(1024);
-        Box::leak(v);
+        v.leak();
     }
 }
 ```
 
-At the same time, memory leaked via `Box::leak` is not truly forgotten.\
+At the same time, memory leaked via `leak` method is not truly forgotten.\
 The operating system can map each memory region to the process responsible for it.
 When the process exits, the operating system will reclaim that memory.
 

book/src/07_threads/10_patch.md

@@ -10,9 +10,9 @@ In the non-threaded version of the system, updates were fairly straightforward:
 
 ## Multithreaded updates
 
-The same strategy won't work in the current multi-threaded version,
-because the mutable reference would have to be sent over a channel. The borrow checker would
-stop us, because `&mut Ticket` doesn't satisfy the `'static` lifetime requirement of `SyncSender::send`.
+The same strategy won't work in the current multithreaded version. The borrow checker would
+stop us: `SyncSender<&mut Ticket>` isn't `'static` because `&mut Ticket` doesn't satisfy the `'static` lifetime, therefore
+they can't be captured by the closure that gets passed to `std::thread::spawn`.
 
 There are a few ways to work around this limitation. We'll explore a few of them in the following exercises.
 

book/src/07_threads/11_locks.md

@@ -99,7 +99,7 @@ fn main() {
     let guard = lock.lock().unwrap();
 
     spawn(move || {
-        receiver.recv().unwrap();;
+        receiver.recv().unwrap();
     });
 
     // Try to send the guard over the channel
@@ -118,7 +118,7 @@ error[E0277]: `MutexGuard<'_, i32>` cannot be sent between threads safely
     |  _-----_^
     | | |
     | | required by a bound introduced by this call
-11  | |     receiver.recv().unwrap();;
+11  | |     receiver.recv().unwrap();
 12  | | });
     | |_^ `MutexGuard<'_, i32>` cannot be sent between threads safely
     |

book/src/08_futures/02_spawn.md

@@ -112,7 +112,7 @@ pub async fn work() {
 
 ### `std::thread::spawn` vs `tokio::spawn`
 
-You can think of `tokio::spawn` as the asynchronous sibling of `std::spawn::thread`.
+You can think of `tokio::spawn` as the asynchronous sibling of `std::thread::spawn`.
 
 Notice a key difference: with `std::thread::spawn`, you're delegating control to the OS scheduler.
 You're not in control of how threads are scheduled.

book/src/08_futures/06_async_aware_primitives.md

@@ -52,7 +52,7 @@ Yields to runtime
              Tries to acquire lock
 ```
 
-We have a deadlock. Task B we'll never manage to acquire the lock, because the lock
+We have a deadlock. Task B will never manage to acquire the lock, because the lock
 is currently held by task A, which has yielded to the runtime before releasing the
 lock and won't be scheduled again because the runtime cannot preempt task B.
 

exercises/01_intro/00_welcome/src/lib.rs

@@ -17,7 +17,7 @@
 // You can also find solutions to all exercises in the `solutions` git branch.
 fn greeting() -> &'static str {
     // TODO: fix me 👇
-    "I'm ready to learn Rust!"
+    "I'm ready to __!"
 }
 
 // Your solutions will be automatically verified by a set of tests.

exercises/01_intro/01_syntax/src/lib.rs

@@ -3,7 +3,7 @@
 //  partner in this course and it'll often guide you in the right direction!
 //
 // The input parameters should have the same type of the return type.
-fn compute(a: u32, b: u32) -> u32 {
+fn compute(a, b) -> u32 {
     // Don't touch the function body.
     a + b * 2
 }
@@ -16,4 +16,4 @@ mod tests {
     fn case() {
         assert_eq!(compute(1, 2), 5);
     }
-}
+}

exercises/02_basic_calculator/00_intro/src/lib.rs

@@ -1,6 +1,6 @@
 fn intro() -> &'static str {
     // TODO: fix me 👇
-    "I'm ready to build a calculator in Rust!"
+    "I'm ready to __!"
 }
 
 #[cfg(test)]

exercises/02_basic_calculator/01_integers/src/lib.rs

@@ -1,6 +1,6 @@
 fn compute(a: u32, b: u32) -> u32 {
     // TODO: change the line below to fix the compiler error and make the tests pass.
-    a + b * 4u32
+    a + b * 4u8
 }
 
 #[cfg(test)]

exercises/02_basic_calculator/02_variables/src/lib.rs

@@ -8,7 +8,7 @@
 pub fn speed(start: u32, end: u32, time_elapsed: u32) -> u32 {
     // TODO: define a variable named `distance` with the right value to get tests to pass
     //  Do you need to annotate the type of `distance`? Why or why not?
-    let distance: u32 = end - start;
+
     // Don't change the line below
     distance / time_elapsed
 }

exercises/02_basic_calculator/03_if_else/src/lib.rs

@@ -1,6 +1,6 @@
 /// Return `true` if `n` is even, `false` otherwise.
 fn is_even(n: u32) -> bool {
-    n % 2 == 0
+    todo!()
 }
 
 #[cfg(test)]

exercises/02_basic_calculator/04_panics/src/lib.rs

@@ -2,9 +2,7 @@
 /// calculate the average speed of the journey.
 fn speed(start: u32, end: u32, time_elapsed: u32) -> u32 {
     // TODO: Panic with a custom message if `time_elapsed` is 0
-    if time_elapsed == 0 {
-        panic!("The journey took no time at all, that's impossible!");
-    }
+
     (end - start) / time_elapsed
 }
 

exercises/02_basic_calculator/05_factorial/src/lib.rs

@@ -9,13 +9,6 @@
 // `factorial(2)` to return `2`, and so on.
 //
 // Use only what you learned! No loops yet, so you'll have to use recursion!
-fn factorial(n: u16) -> u16 {
-    if n == 0 {
-        1
-    } else {
-        n * factorial(n - 1)
-    }
-}
 
 #[cfg(test)]
 mod tests {

exercises/02_basic_calculator/06_while/src/lib.rs

@@ -4,13 +4,7 @@ pub fn factorial(n: u32) -> u32 {
     // interprets as "I'll get back to this later", thus
     // suppressing type errors.
     // It panics at runtime.
-    let mut result: u32 = 1; // base case
-    let mut i: u32 = 1;
-    while i <= n {
-        result *= i;
-        i += 1;
-    }
-    result
+    todo!()
 }
 
 #[cfg(test)]

exercises/02_basic_calculator/07_for/src/lib.rs

@@ -1,10 +1,6 @@
 // Rewrite the factorial function using a `for` loop.
 pub fn factorial(n: u32) -> u32 {
-    let mut result: u32 = 1; // base case
-    for i in 2..=n {
-        result *= i;
-    }
-    result
+    todo!()
 }
 
 #[cfg(test)]

exercises/02_basic_calculator/09_saturating/src/lib.rs

@@ -1,9 +1,9 @@
 pub fn factorial(n: u32) -> u32 {
-    let mut result: u32 = 1;
+    let mut result = 1;
     for i in 1..=n {
         // Use saturating multiplication to stop at the maximum value of u32
         // rather than overflowing and wrapping around
-        result = result.saturating_mul(i);
+        result *= i;
     }
     result
 }

exercises/02_basic_calculator/10_as_casting/src/lib.rs

@@ -6,7 +6,7 @@ mod tests {
 
     #[test]
     fn u16_to_u32() {
-        let v: u32 = 47;
+        let v: u32 = todo!();
         assert_eq!(47u16 as u32, v);
     }
 
@@ -24,14 +24,14 @@ mod tests {
         // You could solve this by using exactly the same expression as above,
         // but that would defeat the purpose of the exercise. Instead, use a genuine
         // `i8` value that is equivalent to `255` when converted from `u8`.
-        let y: i8 = -1;
+        let y: i8 = todo!();
 
         assert_eq!(x, y);
     }
 
     #[test]
     fn bool_to_u8() {
-        let v: u8 = 1;
+        let v: u8 = todo!();
         assert_eq!(true as u8, v);
     }
 }

exercises/03_ticket_v1/00_intro/src/lib.rs

@@ -1,6 +1,6 @@
 fn intro() -> &'static str {
     // TODO: fix me 👇
-    "I'm ready to start modelling a software ticket!"
+    "I'm ready to __!"
 }
 
 #[cfg(test)]

exercises/03_ticket_v1/01_struct/src/lib.rs

@@ -4,16 +4,6 @@
 //
 // It should also have a method named `is_available` that returns a `true` if the quantity is
 // greater than 0, otherwise `false`.
-struct Order {
-    price: u8,
-    quantity: u8,
-}
-
-impl Order {
-    fn is_available(self) -> bool {
-        self.quantity > 0
-    }
-}
 
 #[cfg(test)]
 mod tests {

exercises/03_ticket_v1/02_validation/src/lib.rs

@@ -17,22 +17,7 @@ impl Ticket {
     // as well as some `String` methods. Use the documentation of Rust's standard library
     // to find the most appropriate options -> https://doc.rust-lang.org/std/string/struct.String.html
     fn new(title: String, description: String, status: String) -> Self {
-        if status != "To-Do" && status != "In Progress" && status != "Done" {
-            panic!("Only `To-Do`, `In Progress`, and `Done` statuses are allowed")
-        }
-        if title.is_empty() {
-            panic!("Title cannot be empty")
-        }
-        if description.is_empty() {
-            panic!("Description cannot be empty")
-        }
-        if title.len() > 50 {
-            panic!("Title cannot be longer than 50 bytes")
-        }
-        if description.len() > 500 {
-            panic!("Description cannot be longer than 500 bytes")
-        }
-
+        todo!();
         Self {
             title,
             description,

exercises/03_ticket_v1/03_modules/src/lib.rs

@@ -1,7 +1,6 @@
 mod helpers {
     // TODO: Make this code compile, either by adding a `use` statement or by using
     //  the appropriate path to refer to the `Ticket` struct.
-    use super::Ticket;
 
     fn create_todo_ticket(title: String, description: String) -> Ticket {
         Ticket::new(title, description, "To-Do".into())

exercises/03_ticket_v1/04_visibility/src/lib.rs

@@ -1,12 +1,12 @@
 mod ticket {
-    pub struct Ticket {
+    struct Ticket {
         title: String,
         description: String,
         status: String,
     }
 
     impl Ticket {
-        pub fn new(title: String, description: String, status: String) -> Ticket {
+        fn new(title: String, description: String, status: String) -> Ticket {
             if title.is_empty() {
                 panic!("Title cannot be empty");
             }
@@ -48,14 +48,14 @@ mod tests {
 
         // You should be seeing this error when trying to run this exercise:
         //
-        // error[E0616]: field `description` of struct `encapsulation::ticket::Ticket` is private
+        // error[E0616]: field `description` of struct `Ticket` is private
         //    |
         //    |              assert_eq!(ticket.description, "A description");
         //    |                         ^^^^^^^^^^^^^^^^^^
         //
         // TODO: Once you have verified that the below does not compile,
         //   comment the line out to move on to the next exercise!
-        // assert_eq!(ticket.description, "A description");
+        assert_eq!(ticket.description, "A description");
     }
 
     fn encapsulation_cannot_be_violated() {
@@ -68,10 +68,10 @@ mod tests {
         //
         // TODO: Once you have verified that the below does not compile,
         //   comment the lines out to move on to the next exercise!
-        // let ticket = Ticket {
-        //    title: "A title".into(),
-        //    description: "A description".into(),
-        //    status: "To-Do".into(),
-        // };
+        let ticket = Ticket {
+            title: "A title".into(),
+            description: "A description".into(),
+            status: "To-Do".into(),
+        };
     }
 }

exercises/03_ticket_v1/05_encapsulation/src/lib.rs

@@ -34,17 +34,6 @@ pub mod ticket {
         //  - `title` that returns the `title` field.
         //  - `description` that returns the `description` field.
         //  - `status` that returns the `status` field.
-        pub fn title(self) -> String {
-            self.title
-        }
-
-        pub fn description(self) -> String {
-            self.description
-        }
-
-        pub fn status(self) -> String {
-            self.status
-        }
     }
 }
 

exercises/03_ticket_v1/06_ownership/src/lib.rs

@@ -34,16 +34,16 @@ impl Ticket {
         }
     }
 
-    pub fn title(&self) -> &String {
-        &self.title
+    pub fn title(self) -> String {
+        self.title
     }
 
-    pub fn description(&self) -> &String {
-        &self.description
+    pub fn description(self) -> String {
+        self.description
     }
 
-    pub fn status(&self) -> &String {
-        &self.status
+    pub fn status(self) -> String {
+        self.status
     }
 }
 

exercises/03_ticket_v1/07_setters/src/lib.rs

@@ -11,9 +11,21 @@ pub struct Ticket {
 
 impl Ticket {
     pub fn new(title: String, description: String, status: String) -> Ticket {
-        validate_title(&title);
-        validate_description(&description);
-        validate_status(&status);
+        if title.is_empty() {
+            panic!("Title cannot be empty");
+        }
+        if title.len() > 50 {
+            panic!("Title cannot be longer than 50 bytes");
+        }
+        if description.is_empty() {
+            panic!("Description cannot be empty");
+        }
+        if description.len() > 500 {
+            panic!("Description cannot be longer than 500 bytes");
+        }
+        if status != "To-Do" && status != "In Progress" && status != "Done" {
+            panic!("Only `To-Do`, `In Progress`, and `Done` statuses are allowed");
+        }
 
         Ticket {
             title,
@@ -33,45 +45,6 @@ impl Ticket {
     pub fn status(&self) -> &String {
         &self.status
     }
-
-    pub fn set_title(&mut self, title: String) {
-        validate_title(&title);
-        self.title = title;
-    }
-
-    pub fn set_description(&mut self, description: String) {
-        validate_description(&description);
-        self.description = description;
-    }
-
-    pub fn set_status(&mut self, status: String) {
-        validate_status(&status);
-        self.status = status;
-    }
-}
-
-fn validate_title(title: &String) {
-    if title.is_empty() {
-        panic!("Title cannot be empty");
-    }
-    if title.len() > 50 {
-        panic!("Title cannot be longer than 50 bytes");
-    }
-}
-
-fn validate_description(description: &String) {
-    if description.is_empty() {
-        panic!("Description cannot be empty");
-    }
-    if description.len() > 500 {
-        panic!("Description cannot be longer than 500 bytes");
-    }
-}
-
-fn validate_status(status: &String) {
-    if status != "To-Do" && status != "In Progress" && status != "Done" {
-        panic!("Only `To-Do`, `In Progress`, and `Done` statuses are allowed");
-    }
 }
 
 #[cfg(test)]

exercises/03_ticket_v1/08_stack/src/lib.rs

@@ -6,16 +6,16 @@ mod tests {
 
     #[test]
     fn u16_size() {
-        assert_eq!(size_of::<u16>(), 2);
+        assert_eq!(size_of::<u16>(), todo!());
     }
 
     #[test]
     fn i32_size() {
-        assert_eq!(size_of::<i32>(), 4);
+        assert_eq!(size_of::<i32>(), todo!());
     }
 
     #[test]
     fn bool_size() {
-        assert_eq!(size_of::<bool>(), 1);
+        assert_eq!(size_of::<bool>(), todo!());
     }
 }

exercises/03_ticket_v1/09_heap/src/lib.rs

@@ -13,7 +13,7 @@ mod tests {
 
     #[test]
     fn string_size() {
-        assert_eq!(size_of::<String>(), 24);
+        assert_eq!(size_of::<String>(), todo!());
     }
 
     #[test]
@@ -23,6 +23,6 @@ mod tests {
         // but, in general, the memory layout of structs is a more complex topic.
         // If you're curious, check out the "Data layout" section of the Rustonomicon
         // https://doc.rust-lang.org/nomicon/data.html for more information.
-        assert_eq!(size_of::<Ticket>(), 72);
+        assert_eq!(size_of::<Ticket>(), todo!());
     }
 }

exercises/03_ticket_v1/10_references_in_memory/src/lib.rs

@@ -13,16 +13,16 @@ mod tests {
 
     #[test]
     fn u16_ref_size() {
-        assert_eq!(size_of::<&u16>(), 8);
+        assert_eq!(size_of::<&u16>(), todo!());
     }
 
     #[test]
     fn u64_mut_ref_size() {
-        assert_eq!(size_of::<&mut u64>(), 8);
+        assert_eq!(size_of::<&mut u64>(), todo!());
     }
 
     #[test]
     fn ticket_ref_size() {
-        assert_eq!(size_of::<&Ticket>(), 8);
+        assert_eq!(size_of::<&Ticket>(), todo!());
     }
 }

exercises/03_ticket_v1/11_destructor/src/lib.rs

@@ -2,7 +2,7 @@
 // We'll pick the concept up again in a later chapter after covering traits and
 // interior mutability.
 fn outro() -> &'static str {
-    "I have a basic understanding of destructors!"
+    "I have a basic understanding of __!"
 }
 
 #[cfg(test)]

exercises/03_ticket_v1/12_outro/src/lib.rs

@@ -11,74 +11,3 @@
 // Integration here has a very specific meaning: they test **the public API** of your project.
 // You'll need to pay attention to the visibility of your types and methods; integration
 // tests can't access private or `pub(crate)` items.
-pub struct Order {
-    product_name: String,
-    quantity: u32,
-    unit_price: u32,
-}
-
-impl Order {
-    pub fn new(product_name: String, quantity: u32, unit_price: u32) -> Order {
-        validate_product_name(&product_name);
-        validate_quantity(&quantity);
-        validate_unit_price(&unit_price);
-
-        Order {
-            product_name,
-            quantity,
-            unit_price,
-        }
-    }
-
-    pub fn product_name(&self) -> &String {
-        &self.product_name
-    }
-
-    pub fn quantity(&self) -> &u32 {
-        &self.quantity
-    }
-
-    pub fn unit_price(&self) -> &u32 {
-        &self.unit_price
-    }
-
-    pub fn set_product_name(&mut self, product_name: String) {
-        validate_product_name(&product_name);
-        self.product_name = product_name;
-    }
-
-    pub fn set_quantity(&mut self, quantity: u32) {
-        validate_quantity(&quantity);
-        self.quantity = quantity;
-    }
-
-    pub fn set_unit_price(&mut self, unit_price: u32) {
-        validate_unit_price(&unit_price);
-        self.unit_price = unit_price;
-    }
-
-    pub fn total(&self) -> u32 {
-        self.quantity * self.unit_price
-    }
-}
-
-fn validate_product_name(product_name: &String) {
-    if product_name.is_empty() {
-        panic!("Product name cannot be empty");
-    }
-    if product_name.len() > 300 {
-        panic!("Product name cannot be longer than 300 bytes");
-    }
-}
-
-fn validate_quantity(quantity: &u32) {
-    if quantity == &0 {
-        panic!("Quantity must be greater than zero");
-    }
-}
-
-fn validate_unit_price(unit_price: &u32) {
-    if unit_price == &0 {
-        panic!("Unit price must be greater than zero");
-    }
-}

exercises/04_traits/00_intro/src/lib.rs

@@ -1,6 +1,6 @@
 fn intro() -> &'static str {
     // TODO: fix me 👇
-    "I'm ready to learn about traits!"
+    "I'm ready to __!"
 }
 
 #[cfg(test)]

exercises/04_traits/01_trait/src/lib.rs

@@ -3,22 +3,6 @@
 //
 // Then implement the trait for `u32` and `i32`.
 
-pub trait IsEven {
-    fn is_even(self) -> bool;
-}
-
-impl IsEven for u32 {
-    fn is_even(self) -> bool {
-        self % 2 == 0
-    }
-}
-
-impl IsEven for i32 {
-    fn is_even(self) -> bool {
-        self % 2 == 0
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

exercises/04_traits/02_orphan_rule/src/lib.rs

@@ -3,3 +3,9 @@
 //  a foreign type (`u32`, from `std`).
 //  Look at the compiler error to get familiar with what it looks like.
 //  Then delete the code below and move on to the next exercise.
+
+impl PartialEq for u32 {
+    fn eq(&self, _other: &Self) -> bool {
+        todo!()
+    }
+}

exercises/04_traits/03_operator_overloading/src/lib.rs

@@ -8,13 +8,7 @@ struct Ticket {
 
 // TODO: Implement the `PartialEq` trait for `Ticket`.
 
-impl PartialEq for Ticket {
-    fn eq(&self, other: &Self) -> bool {
-        self.title == other.title
-            && self.description == other.description
-            && self.status == other.status
-    }
-}
+impl PartialEq for Ticket {}
 
 #[cfg(test)]
 mod tests {

exercises/04_traits/04_derive/src/lib.rs

@@ -8,7 +8,7 @@
 // print both sides of the comparison to the terminal.
 // If the compared type doesn't implement `Debug`, it doesn't know how to represent them!
 
-#[derive(Debug, PartialEq)]
+#[derive(PartialEq)]
 struct Ticket {
     title: String,
     description: String,

exercises/04_traits/05_trait_bounds/src/lib.rs

@@ -6,10 +6,7 @@
 // collections (e.g. BTreeMap).
 
 /// Return the minimum of two values.
-pub fn min<T>(left: T, right: T) -> T
-where
-    T: Ord,
-{
+pub fn min<T>(left: T, right: T) -> T {
     if left <= right {
         left
     } else {

exercises/04_traits/14_outro/tests/integration.rs

@@ -6,11 +6,12 @@ fn test_saturating_u16() {
     let b: SaturatingU16 = 5u8.into();
     let c: SaturatingU16 = u16::MAX.into();
     let d: SaturatingU16 = (&1u16).into();
+    let e = &c;
 
     assert_eq!(a + b, SaturatingU16::from(15u16));
     assert_eq!(a + c, SaturatingU16::from(u16::MAX));
     assert_eq!(a + d, SaturatingU16::from(11u16));
     assert_eq!(a + a, 20u16);
     assert_eq!(a + 5u16, 15u16);
-    assert_eq!(a + &u16::MAX, SaturatingU16::from(u16::MAX));
+    assert_eq!(a + e, SaturatingU16::from(u16::MAX));
 }

exercises/06_ticket_management/02_vec/src/lib.rs

@@ -43,7 +43,7 @@ mod tests {
     }
 
     #[test]
-    fn thirthieth() {
+    fn thirtieth() {
         assert_eq!(fibonacci(30), 832040);
     }
 }

exercises/06_ticket_management/11_mutable_slices/src/lib.rs

@@ -1,6 +1,5 @@
-// TODO: Define a function named `lowercase` that converts all characters in a string to lowercase,
-//  modifying the input in place.
-//  Does it need to take a `&mut String`? Does a `&mut [str]` work? Why or why not?
+// TODO: Define a function named `squared` that raises all `i32`s within a slice to the power of 2.
+//  The slice should be modified in place.
 
 #[cfg(test)]
 mod tests {
@@ -8,29 +7,22 @@ mod tests {
 
     #[test]
     fn empty() {
-        let mut s = String::from("");
-        lowercase(&mut s);
-        assert_eq!(s, "");
+        let mut s = vec![];
+        squared(&mut s);
+        assert_eq!(s, vec![]);
     }
 
     #[test]
-    fn one_char() {
-        let mut s = String::from("A");
-        lowercase(&mut s);
-        assert_eq!(s, "a");
+    fn one() {
+        let mut s = [2];
+        squared(&mut s);
+        assert_eq!(s, [4]);
     }
 
     #[test]
-    fn multiple_chars() {
-        let mut s = String::from("Hello, World!");
-        lowercase(&mut s);
-        assert_eq!(s, "hello, world!");
-    }
-
-    #[test]
-    fn mut_slice() {
-        let mut s = "Hello, World!".to_string();
-        lowercase(s.as_mut_str());
-        assert_eq!(s, "hello, world!");
+    fn multiple() {
+        let mut s = vec![2, 4];
+        squared(&mut s);
+        assert_eq!(s, vec![4, 16]);
     }
 }

exercises/07_threads/08_client/src/lib.rs

@@ -38,7 +38,7 @@ enum Command {
     },
 }
 
-pub fn server(receiver: Receiver<Command>) {
+fn server(receiver: Receiver<Command>) {
     let mut store = TicketStore::new();
     loop {
         match receiver.recv() {