How to represent shared mutable state?

by

The cell documentation page has rather good examples. Rust will always try to protect you from doing bad things (like having two mutable references to the same thing). Therefor it’s not quite as “easy” as using Rust’s built-in references, since you need to do runtime-checking (Rust references are checked at compile-time).

The RefCell type exists just for that. It checks the mutability rules at runtime. You will get some memory and computation-time overhead, but you end up with the same memory-safety that Rust promises in it’s compile-time checks.

Your example ported to RefCell looks like the following.

use std::cell::RefCell;

struct Player {
    points: i32,
}

// the lifetime is still needed to guarantee that Resources
// don't outlive their player
struct Resource<'a> {
    owner: &'a RefCell<Player>,
}

impl<'a> Resource<'a> {
    fn test(&self) -> i32 {
        self.owner.borrow().points
    }
}

fn main() {
    let player = RefCell::new(Player { points: 0 });
    let mut resources = Vec::new();
    resources.push(Resource { owner: &player });
    player.borrow_mut().points = 30;
    println!("{:?}", resources[0].test());
}

My concern is, if what I’m trying to do is trying to write Java code in Rust, can it be done in a Rust-way without sacrificing compile time safety? Avoid that shared mutable state at all?

You are not sacrificing compile-time-safety. Rust makes sure (at compile-time) that you are using your libraries correctly. Still, your program might panic at runtime if you use the borrow* functions. If you use the try_borrow* functions instead, you can check if it succeeded and if not, do some fallback operation.

You can also use a reference counted box of a RefCell to your type (Rc<RefCell<Player>>). Then you only need to make sure that you do not create cycles, or your memory will never be freed. This would be much more Java like (although Java automatically finds cycles).

More Related Contents:

  1. What are Rust’s exact auto-dereferencing rules?
  2. Why is a trait not implemented for a type that clearly has it implemented?
  3. How can I include a module from another file from the same project?
  4. What does “Sized is not implemented” mean?
  5. How do I implement a trait I don’t own for a type I don’t own?
  6. What makes something a “trait object”?
  7. Is it possible to use `impl Trait` as a function’s return type in a trait definition?
  8. Cannot borrow as immutable because it is also borrowed as mutable in function arguments
  9. What is the relation between auto-dereferencing and deref coercion?
  10. What is the return type of the indexing operation?
  11. How to do a binary search on a Vec of floats?
  12. Change enum variant while moving the field to the new variant
  13. I implemented a trait for another trait but cannot call methods from both traits
  14. When is it useful to define multiple lifetimes in a struct?
  15. Moved variable still borrowing after calling `drop`?
  16. What is the difference between Copy and Clone?
  17. Is it possible to have stack allocated arrays with the size determined at runtime in Rust?
  18. Temporary value is freed at the end of this statement [duplicate]
  19. What is the right way to allocate data to pass to an FFI call?
  20. Sharing a struct with trait objects as properties across threads
  21. Calling a generic async function with a (mutably) borrowed argument
  22. Read large files line by line in Rust [duplicate]
  23. Do all primitive types implement the Copy trait?
  24. How to switch between Rust toolchains?
  25. How do I specify that a struct field must implement a trait?
  26. What does Rust’s unary || (parallel pipe) mean?
  27. How to create and write to memory mapped files?
  28. Downcast traits inside Rc for AST manipulation
  29. How to check in Rust if architecture is 32 or 64 bit?
  30. Is there any way to restrict a generic type to one of several types?

Leave a Comment