Variables, Constants, and Data Types

# CHAPTER 4

Variables, Constants, and Data Types #

1. Chapter Introduction #

2. Learning Objectives #

• Declare variables using the let keyword.

• Understand and utilize Immutability by default.

• Make variables mutable using the mut keyword.

• Declare Constants using const.

• Differentiate between Scalar types (integers, floats, booleans, chars) and Compound types (tuples, arrays).

3. Variables and Immutability #

CRITICAL RULE: By default, once a value is bound to a variable name, you cannot change it! This is called Immutability. It makes your code incredibly safe, especially in multi-threaded programs.

fn main() {
    let x = 5;
    println!("The value of x is: {}", x);
    
    // x = 6; // ERROR! Cannot assign twice to immutable variable `x`
}

If you want a variable to be changeable, you must explicitly add the mut (mutable) keyword.

fn main() {
    let mut y = 10; // 'mut' allows the value to change
    println!("Initial y: {}", y);
    
    y = 20; // This is now perfectly fine!
    println!("Updated y: {}", y);
}

4. Constants #

1. 1. You use const instead of let.

1. 2. You CANNOT use mut with const.

1. 3. You MUST explicitly declare the data type.

1. 4. Constants can be declared in the global scope (outside of main).

// Standard convention is UPPERCASE_WITH_UNDERSCORES
const MAX_SPEED: u32 = 120; 

fn main() {
    println!("Max speed is {}", MAX_SPEED);
}

5. Data Types in Rust #

#### A. Scalar Types A scalar type represents a single value. Rust has four primary scalar types:

1. Integers (Whole numbers)

• Signed (can be negative): i8, i16, i32, i64, i128, isize

• Unsigned (positive only): u8, u16, u32, u64, u128, usize

let age: u8 = 25; // Explicit type annotation

2. Floating-Point Numbers (Numbers with decimals)

• f32 (Single precision)

• f64 (Double precision)

let price = 19.99; // Defaults to f64
let weight: f32 = 4.5;

3. Booleans Can only be true or false.

let is_active: bool = true;

4. Characters (char) Represents a single Unicode value (uses single quotes).

let letter: char = 'R';
let emoji = '🚀'; // Emojis are valid characters!

#### B. Compound Types Compound types group multiple values into one type. Rust has two primitive compound types:

1. Tuples Group values with a *variety of different types* into one compound type. Tuples have a fixed length.

fn main() {
    // Tuple of (string, integer, float)
    let person: (&str, i32, f64) = ("Alice", 30, 5.5);
    
    // Access using dot notation and the index
    println!("Name: {}", person.0);
    println!("Age: {}", person.1);
    
    // Destructuring a tuple
    let (name, age, height) = person;
    println!("Destructured: {} is {}", name, age);
}

2. Arrays Group multiple values of the *exact same type*. In Rust, arrays have a fixed length (they cannot grow or shrink).

fn main() {
    // Array of 5 integers
    let numbers: [i32; 5] = [1, 2, 3, 4, 5];
    
    // Access using square brackets
    println!("First number: {}", numbers[0]);
    
    // Initialize an array with the same value repeated
    // Creates [0, 0, 0, 0, 0]
    let zeroes = [0; 5]; 
}

6. Variable Shadowing #

fn main() {
    let spaces = "   "; // String type
    let spaces = spaces.len(); // Re-declared as an integer!
    
    println!("There are {} spaces", spaces);
}

7. Common Mistakes #

• Mutating a non-mut variable: Trying to change a variable declared with just let is the most common beginner error.

• Out of bounds Array access: Attempting to access numbers[10] on an array of length 5 will cause the program to "panic" (crash) safely, rather than allowing hackers to read arbitrary memory like in C/C++.

• Mismatched types: Rust will NOT automatically convert a float to an integer. You cannot do let x: i32 = 5.5;.

8. Best Practices #

• Embrace Immutability: Only use mut when you absolutely need to. Code with immutable variables is easier to read, test, and run concurrently without bugs.

• Let the compiler infer types: You don't need to write let x: i32 = 5;. Just write let x = 5; and let Rust figure it out to keep your code clean.

9. Exercises #

1. 1. Create a mutable integer score set to 0. Add 10 to it and print it.

1. 2. Create a constant PI with the value 3.14159.

1. 3. Create a tuple representing a 3D coordinate (x, y, z) and print the y value using dot notation.

10. MCQs with Answers #

11. Interview Questions #

• Q: Explain the difference between mut and Shadowing.

• Q: Why did the creators of Rust make variables immutable by default?

• Q: What is the difference between an Array and a Tuple in Rust?

12. FAQs #

• When should I use i32 vs u32? Use i32 for general numbers that might be negative. Use u32 (unsigned) when you want to mathematically guarantee the value can never drop below zero (like an age or a counter).

13. Summary #

14. Next Chapter Recommendation #