Rust Shadowing

Rust shadowing

Created By: chatGPT

In Rust, shadowing is a feature that allows you to declare a new variable with the same name as a previous variable. The new variable "shadows" the previous one, meaning that the new variable is used in subsequent code, effectively disregarding the previous variable. Shadowing can be especially useful when you want to change the type of a variable or modify its value without needing to create a new variable name. Let's explore how shadowing works in Rust with an example.

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

    let x = x + 10;
    println!("The value of x after shadowing is: {}", x);
}

In the code above, we first declare a variable x and assign it the value of 5. Then, we print its value. After that, we declare a new x which is set to x + 10. The second declaration shadows the first, so when we print it again, we see that x now holds the value 15. This demonstrates how you can easily change a variable's binding while keeping the same name.

// Output:
// The value of x is: 5
// The value of x after shadowing is: 15

Shadowing can also be used to change the data type of a variable. For example, you might start with a variable of type i32 and then shadow it with a String. This can lead to more concise code when transforming values, as shown below.

fn main() {
    let spaces = "   ";
    let spaces = spaces.len();  // shadowed from String to usize

    println!("Number of spaces: {}", spaces);
}

Here, the spaces variable starts as a String containing whitespace. After shadowing, spaces is now of type usize, representing the length of the original string. This allows you to reuse variable names in a controlled way without conflict. However, it's important to understand the scope and how shadowing might affect debugging and code clarity.

// Output:
// Number of spaces: 3