Variables and Mutability

We already covered the basics of variables and mutability in Guessing Game, but here's a quick review:

By default, variables are immutable.

let x = 5;
x = 6; // this will result in an error

However, they can be made mutable.

let mut x = 5;
x = 6; // this is ok!

Constants

Constants are immutable (cannot use mut), they must be type-annotated, and they must be set to a constant expression, not a function.

const MAX_POINTS: u32 = 100_000;

Here's an example of how to do this:

fn main() {
  let mut points = 0;
  loop {
    println!("{}", points);
    if points >= 100 {
      break;
    }
    points = points + 1;
  }
}

This works. But it's not really clear. Why are we only going up to 100? Any future developer does not know why I'm doing what I'm doing. So let's improve it with a constant!

fn main() {
  const MAX_POINTS: u32 = 100;
  let mut points = 0;
  loop {
    println!("{}", points);
    if points >= MAX_POINTS {
      break;
    }
    points = points + 1;
  }
}

Shadowing

This is where Rust gets a little weird and acts differently than you might expect. So while we can't do this:

let x = 5; // immutable
x = x + 1; // no bueno

We can do this:

let mut x = 5;
x = x + 1;

But we can also do this!

let x = 5; // immutable!
let x = x + 1; // but this works!

​ let is essentially creating a new value and Rust allows you to have a value with the same name as a previous value. This really becomes handy when you want to essentially change the variable type. The Rust Book has a great example of this:

For example, say our program asks a user to show how many spaces they want between some text by inputting space characters, but we really want to store that input as a number:

let spaces = "      ";
let spaces = spaces.len();

If we used mut instead, it would result in a compile-time error because these are two different types.