06. Mutability.md

Understanding Mutability in Rust

Immutable by Default: Safety and Optimization

fn main() {
  let x: i32 = 1;
  x = 2; // Error is raised as it is immutable
  println!("{}", x);
}

In Rust, variables are immutable by default. This means once assigned a value, that value cannot be changed later. This design philosophy prioritizes:

1. Thread Safety: Since data cannot be modified after assignment, there's no need for synchronization when multiple threads access the same data. This simplifies concurrent programming and reduces the risk of race conditions.
2. Optimization: The compiler can make optimizations based on the immutability of data. For example, the compiler knows the value won't change, allowing for efficient code generation.

Making Variables Mutable with mut

You can explicitly declare a variable as mutable using the mut keyword before the variable type. This allows you to modify the value of the variable after assignment.

fn main() {
  let mut x: i32 = 1;
  x = 2; // Now allowed because x is mutable
  println!("{}", x); // Prints 2
}

Choosing Mutability Wisely

• Use immutability whenever possible to leverage thread safety and compiler optimizations.
• Only introduce mutability when necessary, such as when you need to update a value.

Benefits of Immutable Data:

• Thread Safety: No need for synchronization in concurrent access scenarios.
• Reasoning About Code: Easier to understand the behavior of your code as data remains consistent.
• Immutability by Default: The default behavior reduces the chance of accidental modifications.

Summary

Understanding mutability in Rust is essential for writing safe, efficient, and thread-safe programs. By defaulting to immutability and using mut judiciously, you can benefit from Rust's memory management and code optimization features.