Rust Struct Borrowing: Mutable & Immutable Field Solutions

Rust borrowing struct conflicts arise when you need simultaneous mutable and immutable access to different fields of the same struct. The borrow checker prevents this pattern by default, but you can overcome this limitation using several proven techniques like splitting borrows, the reborrow idiom, or smart refactoring approaches.

Contents

• Understanding the Rust Borrowing Problem
• Splitting Borrows: The Standard Solution
• The Reborrow Idiom for Struct Borrowing
• Alternative Borrowing Solutions
• Best Practices for Struct Borrowing
• Code Examples and Implementation
• Sources
• Conclusion

Understanding the Rust Borrowing Problem

When working with Rust structs, you’ve likely encountered the borrow checker’s strict rules that prevent simultaneous mutable and immutable borrowing. This happens because the Rust borrow checker enforces strict aliasing rules to ensure memory safety. Even when you’re accessing different fields within the same struct, the compiler treats the entire struct as a single memory location.

Consider this common scenario:

struct Person {
 name: String,
 age: u32,
 active: bool,
}

fn process(person: &Person, update_age: &mut Person) {
 let name = &person.name; // Immutable borrow
 let new_age = person.age + 1; // Another immutable borrow
 
 update_age.age = new_age; // Mutable borrow - this causes a conflict!
 println!("{} is {} years old", name, new_age);
}

The compiler will flag this as an error because you’re trying to borrow the same struct (person) immutably while also borrowing it mutably through update_age, even though you’re accessing different fields. This limitation in Rust’s borrowing system is a deliberate safety feature, but it creates challenges when you need flexible access patterns.

The core issue stems from how Rust’s borrow checker analyzes memory access. It can’t automatically determine that accessing person.name and update_age.age don’t conflict, since both fields could theoretically be located at overlapping memory regions or have complex relationships. This conservative approach ensures safety but sometimes requires developers to use specific patterns to achieve their desired access patterns.

Splitting Borrows: The Standard Solution

Fortunately, Rust’s borrow checker is sophisticated enough to understand that different fields of a struct can be borrowed simultaneously when they don’t alias. This capability is known as “splitting borrows” and is the most straightforward solution for accessing different fields with different borrowing modes.

The official Rust documentation explains this clearly: “Rust’s borrow checker (borrowck) can see that two different fields of a struct can be borrowed mutably at the same time. A struct’s fields are independent memory locations, so the compiler can prove they don’t alias. The borrow checker does understand structs sufficiently to know that it’s possible to borrow disjoint fields of a struct simultaneously.”

Here’s how you can implement splitting borrows in practice:

struct Data {
 config: String,
 state: u32,
 metadata: Vec<String>,
}

fn process_data(data: &mut Data, read_config: bool) {
 if read_config {
 // Immutable borrow of config field
 let config = &data.config;
 println!("Reading config: {}", config);
 }
 
 // Mutable borrow of state field
 data.state += 1;
 
 // This works because we're borrowing different fields
 // with different access modes
}

The key insight here is that Rust recognizes fields as separate memory locations. When you borrow data.config immutably, it doesn’t prevent you from later borrowing data.state mutably, because the compiler can prove these fields don’t overlap in memory.

Splitting borrows work best when:

• You’re accessing clearly distinct fields
• The borrowing pattern is straightforward and sequential
• You don’t need complex nested borrowing patterns

This approach maintains Rust’s safety guarantees while giving you the flexibility to work with individual struct fields independently.

The Reborrow Idiom for Struct Borrowing

When splitting borrows don’t suffice or when you need more complex borrowing patterns, the “reborrow idiom” provides an elegant solution. This technique converts wrapper types or complex references into standard Rust references that the borrow checker can more easily analyze.

The reborrow idiom is particularly useful when working with structs that contain references or when you need to return multiple borrowed values from a function. As noted in the Bevy cheatbook: “The solution is to use the ‘reborrow’ idiom, a common but non-obvious trick in Rust programming. The ‘reborrow’ trick shown above, effectively converts the wrapper into a regular Rust reference. As it is now a regular Rust &mut reference, instead of a special type, the Rust compiler can allow access to the individual fields of your struct.”

Here’s a practical example of the reborrow idiom in action:

struct Container<'a> {
 item1: &'a str,
 item2: &'a mut String,
}

fn process_container(container: &mut Container) {
 // Reborrow the entire container as a regular &mut reference
 let reborrowed = &mut *container;
 
 // Now we can access different fields with different borrowing modes
 let item1_ref = &reborrowed.item1; // Immutable borrow
 reborrowed.item2.push_str(" modified"); // Mutable borrow
 
 println!("Item1: {}, Item2: {}", item1_ref, reborrowed.item2);
}

The magic happens with &mut *container - this expression dereferences the container and then creates a new mutable reference to it. This “reborrow” gives you a fresh reference that the borrow checker can analyze more flexibly.

Another common use case for reborrowing is when you need to return multiple borrowed values:

struct Database {
 users: Vec<String>,
 settings: HashMap<String, String>,
}

impl Database {
 fn get_borrowed_data(&self) -> (&[String], &HashMap<String, String>) {
 // Reborrow self to create separate references
 let users_ref = &self.users;
 let settings_ref = &self.settings;
 (users_ref, settings_ref)
 }
}

The reborrow idiom is powerful but requires careful understanding of Rust’s ownership system. It’s particularly valuable when:

• You’re working with complex reference patterns
• You need to return multiple borrowed values
• Standard borrowing patterns become too restrictive

Alternative Borrowing Solutions

When splitting borrows and the reborrow idiom don’t meet your needs, several alternative approaches can help resolve Rust borrowing conflicts. These solutions trade some convenience for different types of flexibility or safety guarantees.

Interior Mutability with Cell and RefCell

For cases where you need to mutate data through immutable references, Rust’s interior mutability patterns can help. Cell and RefCell from the std::cell module provide safe ways to mutate data even when you only have immutable access:

use std::cell::Cell;

struct Counter {
 count: Cell<u32>,
}

impl Counter {
 fn new() -> Self {
 Self { count: Cell::new(0) }
 }
 
 fn increment(&self) {
 let current = self.count.get();
 self.count.set(current + 1);
 }
 
 fn get_count(&self) -> u32 {
 self.count.get()
 }
}

Cell works for types that implement Copy, while RefCell provides similar functionality for non-Copy types with runtime borrow checking.

Smart Pointers and Rc/Arc

For more complex ownership scenarios, smart pointers like Rc (reference counting) and Arc (atomic reference counting) can help manage shared ownership:

use std::rc::Rc;

struct SharedData {
 config: Rc<String>,
 state: Rc<u32>,
}

fn process_shared(data: &SharedData) {
 // Multiple immutable borrows are fine with Rc
 let config_ref = &data.config;
 let state_ref = &data.state;
 // ...
}

Custom Reference Types

For specialized use cases, you can create custom reference types that implement the necessary traits to work with Rust’s borrowing system:

struct FieldRef<'a, T> {
 field: &'a mut T,
}

impl<'a, T> FieldRef<'a, T> {
 fn new(parent: &'a mut ParentStruct, field_accessor: fn(&'a mut ParentStruct) -> &'a mut T) -> Self {
 FieldRef { field: field_accessor(parent) }
 }
}

These alternative approaches each have their own trade-offs in terms of performance, safety guarantees, and complexity. The best choice depends on your specific use case and performance requirements.

Best Practices for Struct Borrowing

When working with Rust struct borrowing, following established patterns and best practices can help you avoid common pitfalls and write more maintainable code. These guidelines come from community experience and official recommendations.

Keep Borrowing Scopes Minimal

Restrict borrowing to the smallest possible scope to maximize flexibility:

// Good - borrowing scope is limited
fn process(data: &mut MyStruct) {
 {
 let config = &data.config;
 // Use config immutably
 }
 
 // Now we can borrow mutably
 data.state.update();
}

Prefer Field-Level Borrowing When Possible

Instead of borrowing the entire struct, consider borrowing individual fields directly:

// Instead of:
fn bad_example(data: &mut MyStruct) {
 let processed = process(&data.field);
 data.field = processed;
}

// Prefer:
fn good_example(field: &mut FieldType) {
 let processed = process(field);
 *field = processed;
}

Design Structs for Borrowing Patterns

When designing structs, consider how they’ll be borrowed:

// Better for borrowing patterns
struct BetterDesign {
 public_config: String, // Can be borrowed immutably
 private_state: State, // Internal mutability
}

// Less flexible design
struct LessFlexible {
 data: Vec<ComplexType>, // Harder to borrow partially
}

Use Documentation to Explain Borrowing Patterns

Document your borrowing decisions to help other developers understand the rationale:

/// This struct uses interior mutability for the state field
/// to allow safe concurrent access to the config field.
struct SafeStruct {
 config: String, // Immutable after creation
 state: Mutex<State>, // Protected interior mutability
}

Consider Performance Implications

Some borrowing solutions have performance costs. RefCell adds runtime checks, while Rc and Arc introduce reference counting overhead. Profile your code to ensure the chosen solution doesn’t become a bottleneck.

By following these best practices, you can write Rust code that’s both safe and efficient, while avoiding common borrowing conflicts that might arise from struct field access.

Code Examples and Implementation

Let’s put these borrowing solutions into practice with comprehensive code examples that demonstrate different scenarios and their implementations.

Example 1: Basic Splitting Borrows

struct UserProfile {
 username: String,
 preferences: UserPreferences,
 last_login: SystemTime,
}

fn update_profile(profile: &mut UserProfile, new_prefs: &UserPreferences) {
 // Immutable borrow of username
 let name = &profile.username;
 
 // Mutable borrow of preferences
 profile.preferences = new_prefs.clone();
 
 // Both borrows are fine because they access different fields
 println!("Updated profile for {}", name);
}

Example 2: Complex Reborrow Pattern

struct Container<'a> {
 config: &'a Config,
 state: &'a mut AppState,
 cache: &'a mut Cache,
}

impl<'a> Container<'a> {
 fn get_data(&self) -> &Config {
 &self.config
 }
 
 fn update_state(&mut self) {
 // Reborrow to allow mixed access patterns
 let reborrowed = &mut *self;
 
 // Immutable access to config through reborrowed reference
 let config_ref = &reborrowed.config;
 
 // Mutable access to state and cache
 reborrowed.state.update();
 reborrowed.cache.clear();
 
 println!("Config: {:?}", config_ref);
 }
}

Example 3: Interior Mutability Solution

use std::cell::{Ref, RefCell, RefMut};

struct Service {
 name: String,
 state: RefCell<ServiceState>,
 connections: RefCell<Vec<Connection>>,
}

impl Service {
 fn get_state(&self) -> Ref<ServiceState> {
 self.state.borrow()
 }
 
 fn get_state_mut(&self) -> RefMut<ServiceState> {
 self.state.borrow_mut()
 }
 
 fn add_connection(&self, conn: Connection) {
 let mut connections = self.connections.borrow_mut();
 connections.push(conn);
 }
}

Example 4: Smart Pointer Approach

use std::rc::Rc;
use std::sync::Arc;

struct SharedData {
 config: Arc<Config>,
 metrics: Rc<Metrics>,
}

impl SharedData {
 fn new(config: Config, metrics: Metrics) -> Self {
 Self {
 config: Arc::new(config),
 metrics: Rc::new(metrics),
 }
 }
 
 fn get_config(&self) -> Arc<Config> {
 self.config.clone()
 }
 
 fn get_metrics(&self) -> Rc<Metrics> {
 self.metrics.clone()
 }
}

These examples demonstrate the practical application of different borrowing strategies in real-world scenarios. Each approach has its strengths and should be chosen based on the specific requirements of your application.

Sources

1. Splitting Borrows - The Rustonomicon - Official Rust documentation explaining how the borrow checker handles struct field borrowing and the splitting borrows feature.

2. Borrow multiple fields from struct - Unofficial Bevy Cheat Book - Community resource detailing the reborrow idiom and practical solutions for struct borrowing conflicts.

3. Method borrowing a struct’s field (and not the struct as a whole) - Rust Users Forum - Community discussion with insights into current limitations and potential future improvements for Rust’s borrowing system.

Conclusion

Rust borrowing struct conflicts don’t have to be roadblocks in your development process. By understanding the available solutions—splitting borrows, the reborrow idiom, interior mutability patterns, and smart pointers—you can write code that’s both safe and flexible. The key is to choose the approach that best fits your specific use case while maintaining Rust’s safety guarantees. As you gain experience with Rust’s borrowing system, you’ll develop an intuition for when to use each technique, making your code more efficient and maintainable. Remember that these borrowing patterns are a deliberate part of Rust’s design philosophy, aimed at preventing entire classes of memory safety errors at compile time.