What's the difference between var and _var in Rust?

Question

Given this:

fn main() {
   let variable = [0; 15];
}

The Rust compiler produces this warning:

Answer 1

The key difference between _variable and variable is that first one tells compiler not to give any warnings if we do not use it in our code. Example:

// src/main.rs
fn main() {
    let _x = 1;
    let y = 2;
}

Compiling main.rs gives:

warning: unused variable: `y`
 --> src/main.rs:3:9
  |
3 |     let y = 2;
  |         ^ help: if this is intentional, prefix it with an underscore: `_y`
  |
  = note: `#[warn(unused_variables)]` on by default

The more interesting case is when we are comparing _ with _variable.

Ignoring an Unused Variable by Starting Its Name with _:

The syntax _x still binds the value to the variable, whereas _ doesn’t bind at all.

Consider example:

// src/main.rs
fn main() {
    let s = Some(String::from("Hello!"));

    if let Some(_s) = s {
        println!("found a string");
    }

    println!("{:?}", s);
}

When we try to compile main.rs we get error:

error[E0382]: borrow of moved value: `s`
 --> src/main.rs:8:22
  |
4 |     if let Some(_s) = s {
  |                 -- value moved here
...
8 |     println!("{:?}", s);
  |                      ^ value borrowed here after partial move
  |
  = note: move occurs because value has type `std::string::String`, which does not implement the `Copy` trait
help: borrow this field in the pattern to avoid moving `s.0`
  |
4 |     if let Some(ref _s) = s {
  |                 ^^^

Aha! The syntax _x still binds the value to the variable, which means that we are moving the ownership of s to _s, thus, we can no longer access variable s anymore; which happens when we try to print value of s.

The correct way of doing the above is:

// src/main.rs
fn main() {
    let s = Some(String::from("Hello!"));

    if let Some(_) = s {
        println!("found a string");
    }

    println!("{:?}", s);
}

Above code works just fine. s does not get moved into _, so we can still access it later.

Sometimes I use _ with iterators:

fn main() {
    let v = vec![1, 2, 3];
    let _ = v
        .iter()
        .map(|x| {
            println!("{}", x);
        })
        .collect::>();
}

Compiling gives result:

1
2
3

When doing more complex operations on iterable types above example acts as utility for me.