switch example to hash set, it's cleaner

Author: sunshowers

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

@@ -1,26 +1,25 @@
 #![allow(dead_code)]
 fn main() {}
 
-use std::cell::Cell;
+use std::{collections::HashSet, iter::FromIterator};
 
-fn cell_shortener<'a, 'b>(s: &'a Cell<&'static str>) -> &'a Cell<&'b str> {
+fn hash_set_shortener<'a, 'b>(s: &'a mut HashSet<&'static str>) -> &'a mut HashSet<&'b str> {
     s
 }
 
 // ANCHOR: all
-fn cell_counterexample() {
-    let foo: Cell<&'static str> = Cell::new("foo");
+fn hash_set_counterexample() {
+    let mut foo: HashSet<&'static str> = HashSet::from_iter(["static"]);
     let owned_string: String = "non_static".to_owned();
 
-    // If we pretend that cell_shortener works
-    let shorter_foo = cell_shortener(&foo);
+    // 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 replace `foo`s `Cell` with a
-    // non-static string:
+    // 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.
 }
-// ANCHOR_END: all
+// ANCHOR_END: all

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

@@ -1,11 +1,11 @@
 #![allow(dead_code)]
 fn main() {}
 
-use std::cell::Cell;
+use std::collections::HashSet;
 
 // ANCHOR: all
-fn cell_lengthener<'a, 'b>(s: &'a Cell<&'b str>) -> &'a Cell<&'static str> {
+fn hash_set_lengthener<'a, 'b>(s: &'a mut HashSet<&'b str>) -> &'a mut HashSet<&'static str> {
     s
 }
 
-// ANCHOR_END: all
+// ANCHOR_END: all

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

@@ -1,11 +1,11 @@
 #![allow(dead_code)]
 fn main() {}
 
-use std::cell::Cell;
+use std::collections::HashSet;
 
 // ANCHOR: all
-fn cell_shortener<'a, 'b>(s: &'a Cell<&'static str>) -> &'a Cell<&'b str> {
+fn hash_set_shortener<'a, 'b>(s: &'a mut HashSet<&'static str>) -> &'a mut HashSet<&'b str> {
     s
 }
 
-// ANCHOR_END: all
+// ANCHOR_END: all

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

@@ -6,16 +6,17 @@ its lifetime shorter:
 {{#rustdoc_include ../code/ch01-01-building-an-intuition/lifetime-shortener/src/main.rs:all}}
 ```
 
+<!-- Note: all the code sample names begin with "cell" rather than "hash-set" as you might expect. This is because hash sets should  -->
+
 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 introduce a `Cell` into the
-picture. As a reminder, a `Cell` allows for the data inside it to be changed.
+Now let's make it slightly more complicated. Let's put some strings into a `HashSet`.
 ```rust,does_not_compile
 {{#rustdoc_include ../code/ch01-01-building-an-intuition/cell-shortener/src/main.rs:all}}
 ```
 
-`cell_shortener` doesn't compile :( Can you tell why? Think about it for a minute,
+`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}}
@@ -25,16 +26,16 @@ try using your intuition...
 {{#rustdoc_include ../code/ch01-01-building-an-intuition/cell-counterexample/src/main.rs:all}}
 ```
 
-It isn't just `Cell` which is problematic in this way. `RefCell`, `OnceCell`,
-`Mutex`, `&mut` references -- anything "inside" some sort of mutable context has
-this issue.
+It isn't just `&mut` which is problematic in this way. This also occurs with any sort of interior
+mutability, like `RefCell`, `OnceCell`, or `Mutex` -- anything inside some sort of mutable context
+has this issue.
 
 Now, what about a hypothetical "lengthener" function?
 ```rust,does_not_compile
 {{#rustdoc_include ../code/ch01-01-building-an-intuition/lifetime-lengthener/src/main.rs:all}}
 ```
 
-This is obviously bogus, right? You can't just turn an arbitrary borrowed string
+This is clearly bogus, right? You can't just turn an arbitrary borrowed string
 and make it last the duration of the entire process. Similarly:
 ```rust,does_not_compile
 {{#rustdoc_include ../code/ch01-01-building-an-intuition/cell-lengthener/src/main.rs:all}}
@@ -46,5 +47,8 @@ borrowed string.
 {{#rustdoc_include ../code/ch01-01-building-an-intuition/fn-ptr-lengthener/src/main.rs:all}}
 ```
 
-Ahhh, intuitively, this should work. And it does. You can take a callback that
-takes an arbitrary borrowed string and turn it into one that takes in a static string.
+This feels like should work. You can take a callback that takes an arbitrary borrowed string and
+turn it into one that takes in a static string, since you're weakening the guarantee. And it does.
+
+How can we handle these different cases in a principled way? That's where variance comes in. We're
+going to talk about this in the next chapter, *[Formalizing variance](ch01-02-formalizing-variance.md)*.

src/ch01-02-formalizing-variance.md

@@ -1,7 +1,5 @@
 # Formalizing variance
 
-How can all these intuitions be formalized? It's done through the idea of *variance*.
-
 Some kinds of memory live longer than others.  This is captured through the idea
 of the *outlives* relationship. If `'b` outlives `'a`, it is written as `'b: 'a`.
 For example, in the definition:
@@ -20,7 +18,7 @@ For a type `T<'a>`, `'a` may be:
   * **invariant**, which means that even if `'b: 'a`, nothing can be said about
   the relationship between `T<'b>` and `T<'a>`. This can happen for one of two reasons:
      * If the lifetime is present "inside" some sort of mutable context -- whether
-     a `&mut` reference, or interior mutability like `Cell`/`RefCell`/`Mutex`.
+     a `&mut` reference, or interior mutability like `RefCell`, `OnceCell`, or`Mutex`.
 
      * If the lifetime is used in multiple spots where the variances conflict.
      See [Conflicts and type parameters](./ch01-03-conflicts-and-type-parameters.md) for