No need to deploy anymore.

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

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/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/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/03_ticket_v1/04_visibility/src/lib.rs

@@ -48,7 +48,7 @@ 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");
         //    |                         ^^^^^^^^^^^^^^^^^^

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,6 @@
 // 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?
+//  Does it need to take a `&mut String`? Does a `&mut str` work? Why or why not?
 
 #[cfg(test)]
 mod tests {

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() {