add OnceCell to shared-mutability + splitting burrows speaker notes

training-slides/src/SUMMARY.md

@@ -28,7 +28,7 @@ Using Rust on Windows/macOS/Linux. Requires [Rust Fundamentals](#rust-fundamenta
 * [Lifetimes](./lifetimes.md)
 * [Cargo Workspaces](./cargo-workspaces.md)
 * [Heap Allocation (Box and Rc)](./heap.md)
-* [Shared Mutability (Cell, RefCell)](./shared-mutability.md)
+* [Shared Mutability (Cell, RefCell, OnceCell)](./shared-mutability.md)
 * [Thread Safety (Send/Sync, Arc, Mutex)](./thread-safety.md)
 * [Closures and the Fn/FnOnce/FnMut traits](./closures.md)
 * [Spawning Threads and Scoped Threads](./spawning-threads.md)

training-slides/src/shared-mutability.md

@@ -179,6 +179,29 @@ impl Post {
 }
 ```
 
+Note:
+
+An advanced trainee may ask about the use of `Splitting Borrows` which would allow one to borrow different fields with different mutability semantics, such as
+
+```rust
+struct Foo {
+    a: i32,
+    b: i32,
+    c: i32,
+}
+
+let mut x = Foo {a: 0, b: 0, c: 0};
+let a = &mut x.a;
+let b = &mut x.b;
+let c = &x.c;
+*b += 1;
+let c2 = &x.c;
+*a += 10;
+println!("{} {} {} {}", a, b, c, c2);
+```
+
+Which does work but doesn't solve the problem of declaring `let mut x` to begin with.
+
 ## `RefCell`
 
 A `RefCell` is also safe, but lets you *borrow* or *mutably borrow* the contents.
@@ -252,3 +275,33 @@ To get *shared ownership* and *mutability* you need two things:
 
 * `Rc<RefCell<T>>`
 * (Multi-threaded programs might use `Arc<Mutex<T>>`)
+
+## `OnceCell` for special cases
+
+If you only need to modify a field *once*, a `OnceCell` can help you keep the ownership system checks at compile-time
+
+```rust
+use std::time::Instant;
+
+fn main() {
+    let post = Post {
+        content: String::from("Blah"),
+        ..Post::default()
+    };
+    assert!(post.first_viewed_at.get().is_none());
+    println!("{:?}", post.hn_ranking());
+    assert!(post.first_viewed_at.get().is_some());
+}
+
+#[derive(Debug, Default)]
+struct Post {
+    content: String,
+    first_viewed_at: std::cell::OnceCell<Instant>,
+}
+
+impl Post {
+    fn hn_ranking(&self) -> Instant {
+        *self.first_viewed_at.get_or_init(|| {Instant::now()})
+    }
+}
+```