Ch. 05: further tweak to wording about user1 availability

This is a tricky thing to get “just right”, and I am not *totally* happy
with this solution, but I think it’s actually better without the “as a
whole” given the addition of the sentence at the end indicating that its
fields can still be accessed.

Author: chriskrycho

nostarch/chapter05.md

@@ -214,9 +214,10 @@ on page XX. In this example, we can no longer use `user1` after creating
 `user2` because the `String` in the `username` field of `user1` was moved into
 `user2`. If we had given `user2` new `String` values for both `email` and
 `username`, and thus only used the `active` and `sign_in_count` values from
-`user1`, then `user1` would still be valid after creating `user2`. Both
-`active` and `sign_in_count` are types that implement the `Copy` trait, so the
-behavior we discussed in “Stack-Only Data: Copy” on page XX would apply.
+`user1`, then `user1` would still be valid after creating `user2`. Both `active`
+and `sign_in_count` are types that implement the `Copy` trait, so the behavior
+we discussed in “Stack-Only Data: Copy” on page XX would apply. We can also
+still use `user1.email` in this example, since its value was *not* moved out.
 
 ### Using Tuple Structs Without Named Fields to Create Different Types
 
@@ -345,6 +346,9 @@ won’t work:
 > 3 |     username: &str,
 > 4 ~     email: &'a str,
 >   |
+>
+> For more information about this error, try `rustc --explain E0106`.
+> error: could not compile `structs` (bin "structs") due to 2 previous errors
 > ```
 >
 > In Chapter 10, we’ll discuss how to fix these errors so you can store
@@ -689,7 +693,7 @@ defined on our `Rectangle` type.
 name, they can have parameters and a return value, and they contain some code
 that’s run when the method is called from somewhere else. Unlike functions,
 methods are defined within the context of a struct (or an enum or a trait
-object, which we cover in Chapter 6 and Chapter 17, respectively), and their
+object, which we cover in Chapter 6 and Chapter 18, respectively), and their
 first parameter is always `self`, which represents the instance of the struct
 the method is being called on.
 
@@ -822,6 +826,10 @@ pointer first. In other words, if `object` is a pointer,
 feature called *automatic referencing and dereferencing*. Calling methods is
 one of the few places in Rust that has this behavior.
 >
+> Here’s how it works: when you call a method with `object.something()`, Rust
+> automatically adds in `&`, `&mut`, or `*` so `object` matches the signature of
+> the method. In other words, the following are the same:
+>
 > Here’s how it works: when you call a method with `object.`something`()`, Rust
 automatically adds in `&`, `&mut`, or `*` so `object` matches the signature of
 the method. In other words, the following are the same: