In single-thread Rust, what’s the most idiomatic or concise way to mut borrow one field in a struct and leave the rest available?

by

Summary

The issue at hand is mutually exclusive borrowing in Rust, where a struct (Root) is being borrowed both mutably and immutably at the same time. This is happening because we need to mutably borrow one field (world.entities) in the Root struct while still allowing immutable access to other fields. The current solution involves creating a new struct (RootForEntity) that contains references to the required fields, but this approach is not automated or concise.

Root Cause

The root cause of this issue is due to Rust’s borrow checker, which prevents simultaneous mutable and immutable borrows of the same value. The specific error is caused by the line e.display_link = Some(r.link(&e, &root, display));, where root is being borrowed both mutably (in the for loop) and immutably (in the link method).

Why This Happens in Real Systems

This issue occurs in real systems when:

  • A struct contains multiple fields that need to be accessed simultaneously
  • Some fields require mutable access while others require immutable access
  • The borrow checker prevents simultaneous mutable and immutable borrows

Some common scenarios where this happens include:

  • Game engines, where multiple systems need to access different parts of the game state
  • GUI applications, where multiple widgets need to access different parts of the application state
  • Network servers, where multiple connections need to access different parts of the server state

Real-World Impact

The impact of this issue is:

  • Code complexity: The current solution requires creating a new struct (RootForEntity) and manually copying the required fields
  • Maintenance overhead: The new struct needs to be updated whenever the Root struct changes
  • Performance overhead: The creation of the new struct may incur additional performance costs

Example or Code

// Define the Root struct
struct Root {
    world: World,
    device: Device,
    layouts: Layouts,
    assets: Assets,
    input: Input,
    pipelines: Pipelines,
    sounds: Sounds,
    queue: Queue,
}

// Define the RootForEntity struct
struct RootForEntity {
    device: &Device,
    layouts: &Layouts,
    assets: &Assets,
    input: &Input,
    pipelines: &Pipelines,
    sounds: &Sounds,
    queue: &Queue,
}

// Create a new RootForEntity instance
let rfe = RootForEntity {
    device: &root.device,
    layouts: &root.layouts,
    assets: &root.assets,
    input: &root.input,
    pipelines: &root.pipelines,
    sounds: &root.sounds,
    queue: &root.queue,
};

// Use the RootForEntity instance
for (_, e) in &mut root.world.entities {
    if e.display_link.is_none() {
        if let Some(r) = &e.display_linker {
            e.display_link = Some(r.link(&e, &rfe, display));
        }
    }
}

How Senior Engineers Fix It

Senior engineers can fix this issue by:

  • Refactoring the code: Split the Root struct into smaller, more focused structs that can be borrowed independently
  • Using interior mutability: Use types like RefCell or Mutex to allow mutable access to specific fields while still allowing immutable access to other fields
  • Creating a borrow-friendly API: Design the API to minimize the need for simultaneous mutable and immutable borrows

Why Juniors Miss It

Junior engineers may miss this issue because:

  • Lack of experience: They may not have encountered similar issues before and may not know how to recognize the symptoms
  • Insufficient understanding of Rust’s borrow checker: They may not fully understand how the borrow checker works and how to work with it
  • Focus on getting the code to work: They may be focused on getting the code to compile and run, rather than taking the time to understand the underlying issues and design a more robust solution