add OnceCell to shared-mutability + splitting burrows speaker notes #107
Conversation
miguelraz
changed the title
|
Can you look at the pipeline failures? |
|
Pipeline failures fixed! |
|
Thanks! Left a few comments. |
Co-authored-by: Jonathan Pallant <[email protected]>
Deploying ferrous-systems-rust-training with
|
| Latest commit: |
bd1d774
|
| Status: | 🚫 Build failed. |
|
Can you rebase this on main? It's missing the |
| println!("{} {} {} {}", a, b, c, c2); | ||
| ``` | ||
|
|
||
| The code works, but you *have* to use shadowing with `let a = &mut x.a;` or else the compiler will error. The borrowchecker is particularly frail here - replacing `Foo` with `x = [1,2,3]` and trying to borrow indexes will make it error out. |
There was a problem hiding this comment.
I don't know that "You have to use shadowing" is true here. This code works too:
let mut x = Foo {a: 0, b: 0, c: 0};
let c = &x.c;
x.b += 1;
let c2 = &x.c;
x.a += 10;
println!("{} {} {} {}", x.a, x.b, c, c2);The main take-away I think we want here is that the borrow checker is special-cased for borrowing fields in structs and tuples, and the magic there does not apply to borrowing elements using the indexing operator, like with arrays or hashmaps:
This also works:
let mut z = (1, 2);
let r = &z.1;
z.0 += 1;
println!("{:?}, {}", z, r);This does not:
let mut z = [1, 2];
let r = &z[1];
z[0] += 1;
println!("{:?}, {}", z, r);|
|
||
| ## `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 |
There was a problem hiding this comment.
Can we link to the std-library docs on OnceCell?
| } | ||
| ``` | ||
|
|
||
| A [LazyCell](https://doc.rust-lang.org/std/cell/struct.LazyCell.html) will do this initialization lazily, and a [LazyLock](https://doc.rust-lang.org/std/sync/struct.LazyLock.html) will do it in a threadsafe way. |
There was a problem hiding this comment.
I'm afraid I didn't understand the difference between OnceCell and LazyCell after reading this note. I also observe that OnceLock exists.
The primary difference is that a LazyCell owns its initialisation function - it is passed when the cell is constructed, not when the cell is accessed. See https://doc.rust-lang.org/std/cell/index.html#oncecellt and https://doc.rust-lang.org/std/cell/index.html#lazycellt-f. However both are equally 'lazy' in that the function is not called at construction time - it is only called on first access (either explicitly or implicitly).
Learnings from Open Intro to Rust with Aman.