fix hash set example

Author: sunshowers

code/ch01-01-building-an-intuition/cell-counterexample/src/main.rs

@@ -9,17 +9,18 @@ fn hash_set_shortener<'a, 'b>(s: &'a mut HashSet<&'static str>) -> &'a mut HashS
 
 // ANCHOR: all
 fn hash_set_counterexample() {
-    let mut foo: HashSet<&'static str> = HashSet::from_iter(["static"]);
+    let mut my_set: HashSet<&'static str> = HashSet::from_iter(["static"]);
     let owned_string: String = "non_static".to_owned();
-  
-    // If we pretend that hash_set_shortener works
-    let shorter_foo = hash_set_shortener(&mut foo);
-  
-    // then `shorter_foo` and `foo` would be aliases of each other, which would
-    // mean that you could use `shorter_foo` to insert a non-static string:
-    shorter_foo.replace(&owned_string);
-  
-    // Now `foo`, which is an alias of `shorter_foo`, has a non-static string
-    // in it! Whoops.
+
+    // If we pretend that hash_set_shortener works...
+    let shorter_set = hash_set_shortener(&mut my_set);
+
+    // then you could use `shorter_set` to insert a non-static string:
+    shorter_set.insert(&owned_string);
+
+    // Now we can drop `shorter_set` to regain the ability to use `my_set`:
+    std::mem::drop(shorter_set);
+
+    // And my_set now has a non-static string in it. Whoops!
 }
 // ANCHOR_END: all

code/ch01-01-building-an-intuition/cell-example/src/main.rs

@@ -1,19 +1,20 @@
 #![allow(dead_code)]
 fn main() {}
 
-use std::cell::Cell;
+use std::collections::HashSet;
+use std::iter::FromIterator;
 
 // ANCHOR: all
-fn cell_example() {
-    // Consider this Cell. It holds a static string.
-    let foo: Cell<&'static str> = Cell::new("foo");
+fn hash_set_example() {
+    // Consider this HashSet over static strings.
+    let mut my_set: HashSet<&'static str> = HashSet::from_iter(["static"]);
 
     // Do you think this can work?
     let owned_string: String = "non_static".to_owned();
-    foo.replace(&owned_string);
+    my_set.insert(&owned_string);
 
-    // Doesn't seem like it can, right? foo promises that what's inside it is
-    // a &'static str, but we tried to put in an owned string scoped to this
+    // Doesn't seem like it can, right? my_set promises that the &strs inside it
+    // are all 'static, but we tried to put in an owned string scoped to this
     // function.
 }
-// ANCHOR_END: all
+// ANCHOR_END: all

code/ch01-01-building-an-intuition/cell-shortener/src/main.rs

@@ -4,7 +4,9 @@ fn main() {}
 use std::collections::HashSet;
 
 // ANCHOR: all
-fn hash_set_shortener<'a, 'b>(s: &'a mut HashSet<&'static str>) -> &'a mut HashSet<&'b str> {
+fn hash_set_shortener<'a, 'b>(
+    s: &'a mut HashSet<&'static str>,
+) -> &'a mut HashSet<&'b str> {
     s
 }
 

src/ch01-01-building-an-intuition.md

@@ -11,17 +11,22 @@ its lifetime shorter:
 Intuitively, this feels like it should compile: if a string lasts for the whole
 process it should also last for any part of it. And it does!
 
-Now let's make it slightly more complicated. Let's put some strings into a `HashSet`.
+Now let's make it a bit more complicated. Consider a mutable reference to a `HashSet`.
+
 ```rust,does_not_compile
 {{#rustdoc_include ../code/ch01-01-building-an-intuition/cell-shortener/src/main.rs:all}}
 ```
 
-`hash_set_shortener` doesn't compile :( Can you tell why? Think about it for a minute,
-try using your intuition...
+`hash_set_shortener` doesn't compile!
+
+Can you tell why? Think about it for a minute, try using your intuition...
+
 ```rust,does_not_compile
 {{#rustdoc_include ../code/ch01-01-building-an-intuition/cell-example/src/main.rs:all}}
 ```
 
+As a counterexample:
+
 ```rust,does_not_compile
 {{#rustdoc_include ../code/ch01-01-building-an-intuition/cell-counterexample/src/main.rs:all}}
 ```