Day 4: Variables and Mutability in Rust – Controlling Change

Introduction

Variables are essential in any programming language because they hold data that we use and manipulate. However, Rust’s approach to variables is unique: by default, variables in Rust are immutable. This means once you assign a value to a variable, you cannot change it unless you specifically declare it as mutable. This design promotes safety and reduces bugs in your programs, but Rust still gives you the flexibility to make variables mutable when needed.

Today, we’ll explore the ins and outs of variables and mutability in Rust.

1. Declaring Variables with let

In Rust, you use the let keyword to declare a variable. However, unlike in many other languages, Rust makes all variables immutable by default.

Example of Immutable Variable:

fn main() {
   let x = 5;
   println!("The value of x is: {}", x);

   // Uncommenting the next line would cause a compile-time error
   // x = 6;  // Error: cannot assign twice to immutable variable `x`
}

In this example, x is assigned the value of 5, and any attempt to change it later would cause a compile-time error because x is immutable.

2. Making Variables Mutable with mut

Sometimes, you need to change the value of a variable after it’s been created. Rust allows this with the mut keyword, which makes a variable mutable.

Example of Mutable Variable:

fn main() {
   let mut y = 10; // y is mutable
   println!("The initial value of y is: {}", y);

   y = 20; // Now we can change the value of y
   println!("The updated value of y is: {}", y);
}
 

In this example, the keyword mut allows us to change the value of y from 10 to 20. Without the mut keyword, Rust would prevent this mutation.

Why Immutability Matters

Rust’s default immutability prevents unintended changes to variables. This helps prevent bugs by making sure data doesn’t accidentally change in ways you don’t expect. Immutability is especially important in concurrent or multithreaded environments, where multiple parts of a program might try to access or change the same data.

By defaulting to immutability, Rust ensures that you think carefully about where and when you need to make data mutable.

3. Variable Shadowing

Rust allows you to “shadow” a variable by using the same variable name multiple times within the same scope. This is different from mutability because each re-declaration creates a new variable. Shadowing allows you to reassign a variable with a new value or even a different type.

Example of Variable Shadowing:

fn main() {
   let x = 5; // First declaration of x
   let x = x + 1; // Shadowing x with a new value (6)
   let x = x * 2; // Shadowing x again with a new value (12)

   println!("The final value of x is: {}", x);
}

In this example, x is re-declared twice, each time with a new value. The final value printed is 12. Shadowing allows you to transform the value of a variable without making it mutable.

You can even change the type of a variable when shadowing:

Example:

fn main() {
   let spaces = "   ";  // spaces is a string slice
   let spaces = spaces.len();  // spaces is now an integer

   println!("The number of spaces is: {}", spaces);
}

Here, we start with a string, then shadow it with an integer representing the length of the string.

4. Type Inference and Explicit Type Annotations

Rust is a statically typed language, which means that the type of every variable must be known at compile time. However, Rust has powerful type inference, so you don’t always need to explicitly define the type of a variable. Rust can often infer the type from the context.

Example of Type Inference:

fn main() {
   let x = 5; // Rust infers that x is an i32
   let y = 3.14; // Rust infers that y is an f64
}

If you want, you can also specify the type explicitly using type annotations.

Example of Explicit Type Annotations:

fn main() {
   let z: i32 = 42; // Explicitly declare that z is of type i32
   let pi: f64 = 3.14159; // Explicitly declare pi as an f64 (double precision float)
}
 

When to Use Type Annotations

• Clarity: Sometimes, it’s useful to explicitly declare the type to make the code more readable or avoid confusion, especially when working with complex data types.
• Performance: In performance-critical code, explicitly typing variables can help ensure Rust uses the most efficient data type.

5. Constants in Rust

Constants in Rust are immutable and must always have a type annotation. Constants can be declared globally and can hold values that are valid for the entire runtime of the program.

Example of Constants:

const MAX_POINTS: u32 = 108_000;
fn main() {
   println!("The maximum points allowed are: {}", MAX_POINTS);
}
 

• Constants are defined with the const keyword.
• Constants must always have a type declared.
• Constants are useful for values that do not change and are shared across different parts of the program.

6. Scope and Lifetime of Variables

The scope of a variable in Rust begins when it is declared and ends when it goes out of scope, typically when the block ({}) in which the variable is declared ends. Rust uses this scoping to manage memory effectively, especially with the ownership model.

Example:

fn main() {
   {
       let x = 5;  // x is in scope
       println!("x is: {}", x);
   }  // x goes out of scope here
   // println!("{}", x); // This would cause a compile-time error
}
 

In this example, x is declared inside the inner block and is not accessible outside of it.

Conclusion

In this session, we’ve learned about the essential role of variables in Rust. Rust’s emphasis on immutability by default encourages safer and more predictable programs, but with the mut keyword, you still have the flexibility to change variables when needed. We also covered variable shadowing, type inference, and constants, all of which play an important role in Rust’s design.

In the next session, we’ll explore data types in Rust, diving into how Rust manages integers, floating-point numbers, booleans, and more.