What does Some() do on the left hand side of a variable assignment?

Question

I was reading some Rust code and I came across this line

if let Some(path) = env::args().nth(1) {

Inside of this function

f         


        

Answer 1

From the reference :

An if let expression is semantically similar to an if expression but in place of a condition expression it expects the keyword let followed by a refutable pattern, an = and an expression. If the value of the expression on the right hand side of the = matches the pattern, the corresponding block will execute, otherwise flow proceeds to the following else block if it exists. Like if expressions, if let expressions have a value determined by the block that is evaluated.

In here the important part is refutability. What it means refutable pattern in here it can be in different forms. For example :

enum Test {
    First(String, i32, usize),
    Second(i32, usize),
    Third(i32),
}

You can check the x's value for a value for 3 different pattern like :

fn main() {
    let x = Test::Second(14, 55);
    if let Test::First(a, b, c) = x {}
    if let Test::Second(a, b) = x {} //This block will be executed
    if let Test::Third(a) = x {}
}

This is called refutability. But consider your code like this:

enum Test {
    Second(i32, usize),
}

fn main() {
    let x = Test::Second(14, 55);
    if let Test::Second(a, b) = x {}
}

This code will not compile because x's pattern is obvious, it has single pattern. You can get more information from the reference of refutability.

Also you are not right thinking for this:

if let path = Some(env::args().nth(1)) {

Compiler will throw error like irrefutable if-let pattern because as the reference says: "keyword let followed by a refutable pattern". In here there is no refutable pattern after "let". Actually this code tries to create a variable named path which is an Option and this make no sense because there is no "If" needed,

Instead Rust expects from you to write like this:

let path = Some(env::args().nth(1)); // This will be seem like Some(Some(value))

Answer 2

The other answers go into a lot of detail, which might be more than you need to know.

Essentially, this:

if let Some(path) = env::args().nth(1) {
    // Do something with path
} else {
    // otherwise do something else
}

is identical to this:

match env::args().nth(1) {
    Some(path) => { /* Do something with path */ }
    _          => { /* otherwise do something else */ }
}