How to represent a shared mutable state?


I'm trying to learn Rust, but the only thing I do is keep hitting the wall trying to shoehorn familiar (to me) Java concepts into its type system. Or try to shoehorn Haskell concepts, etc.

Let's say I want to write a game, there is a Player and many Resources. Each Resource can be owned by one Player.

struct Player<'a> {
    points: i32

struct Resource<'a> {
    owner: Option<&'a Player<'a>>

fn main() {
    let mut player = Player{points: 0};
    let mut resources = Vec::new();
    resources.push(Resource{owner: Some(&player)});

It doesn't compile, because I can't have the resource point to player, while at the same time modifying it. Moreover, if the Resource owned a mutable reference to Player, I couldn't even have two Resources with the same owner.

What is the Rust way to solve such cases?

EDIT: I oversimplified my question, and while Shepmaster's answer is a correct to it, it's not what I wanted to get (because what I asked was not what I really wanted to ask). I'll try to rephrase it and add more context.

  1. Say the resources are connected in some way - the map of all resources forms a (un)directed graph.
  2. Each player can own many resources, each resource can be owned by one player. The player should be able to get points from resources he owns. I thought of a signature like: fn addPoints(&mut self, allResources: &ResourcesMap) -> ().
  3. The player can take over a resource connected to one of his resources from another player. It could result in some points loss for the other player.


  1. How to represent such graph in Rust (a possibly cyclic structure, where each node can be pointed to from many nodes)?
  2. Here is the original problem. If the Resource points to a Player, I can't modify the player!
  3. Here is the reason for Resource to point to Player - the natural way to do such operation, would be to start from some of Player A's resources, move through the map to a player's B resource and from that resource to player B to subtract the points. It just doesn't seem natural in Rust (at least for me).

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

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

impl<'a> Resource<'a> {
    fn test(&self) -> i32 {

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());