Interior Mutability Patterns in Rust

https://pitdicker.github.io/Interior-mutability-patterns/

by fanf2 • 7 years ago

84 12 7 years ago

pitdicker.github.io

Edward9• 7 years ago

Really enjoyed the read! Two minor things I found: downgrade(&self) should be downgrade(self), and rw2 and rw3 have TCell parameters, should these not be QCells?

nixpulvis• 7 years ago

GhostCell seems worth reading more into.

OnceCell is being discussed as part of https://github.com/rust-lang/rfcs/pull/2788 too.

Dowwie• 7 years ago

Don't miss the author's second installment to this series. Navigate to the index of the blog to see part 2 at the top.

jnordwick4• 7 years ago

Interior mutability to always seemed like a hack around the borrow check and type system instead of just fixing those parts of the language itself. If the single mutable borrow idea isn't working out so much that you need to have idioms like interior mutability, maybe you should relax the requirements or provide a more direct of doing this.

Why not introduce a new borrow notation besides const and mut, add a multimut or something that makes it very clear instead of these hacky solutions.

firethief• 7 years ago

Interior mutability is a principled way to relax the requirements. Multimut exists for really low-level code; it's spelled *mut.

jnordwick4• 7 years ago

Saying it doesn't make it true. There is nothing principled about it - a pure hack around the borrow checker. It seems to be one of the most unprincipled ways - more like casting away const in c++

And I know what unsafe pointers are, but the special keyword would allow the compiler to understand more about the code's intentions.

edit: I take that back. It seems worse. It would as if there was a way to get rid of const by a series of assignments without ever having to explicitly cast it away.

zozbot2343• 7 years ago

It's not a hack, although I can't really fault you for thinking otherwise. The borrow notations are & (shared) and &mut (exclusive, guarantees mutability regardless of type). 'Interior mutability' is a way of enabling shared data to be mutable. See https://limpet.net/mbrubeck/2019/02/07/rust-a-unique-perspec... for a more principled explanation, which even improves on Rust's official docs - this is probably best read in combination w/ OP's series.

jnordwick4• 7 years ago

I know what it is. I've been involved with Rust on and off for about 4 years (now more off than on, but periodically stepping back in).

IM has always seemed like a really bad wart - an intentional breaking of the borrow checking through idiom rather than a language construct. Just as `&` is an shared const ref, `&mut` is an exclusive mutable ref, but for some reason when you get to shared mutable instead of making `multimut&` or something, the language invokes cells then has the audacity to straight-face proclaim you can share mutable references.

I guess if they made `multimut&` ref they would have to admit is is possible I guess. The difference between the syntactic and cell-based representation of that type of share mutable reference always seemed like no real difference.

I do a lot of C++ and having to basically do hygienic macros though template metaprogramming is on the same level. I'd rather just have hygienic macros. Cells are the Rust equivalent of removing const through template without ever having to cast it away explicitly. An intentional breaking of const through idiom rather than syntax.

If tomorrow a shorthand cell was introduced like `shm&` (similar to how `?` was introduced as shorthand for dealing with Result types), it would bring it into the realm of syntax and be much clearer what was going on.

Cell seems like a straight up step around the borrow checker for shared mutability. It should look like the other references.

Rusky• 7 years ago

Your complaint is purely syntactic- `&Cell<T>` exactly the same thing as `&multimut T` semantically.

Other forms of interior mutability genuinely are more than a tweak to borrowck- `RefCell` has a counter, `Mutex` adds synchronization, etc.

Interior Mutability Patterns in Rust

Related Stories