Why do if-let expressions use the assignment operator instead of the equality operator?

Question

I'm trying to wrap my head around if-let expressions. I know what it does but I can't find the rationale behind some details.

The first detail is the use of the assignment operator instead of the equality operator, and the second one is the placement of the operands.

For example:

let a = Some(5);

if let Some(i) = a {
    println!("Hello, {}!", i);
}

In my head its more "legible" this way:

if let Some(i) == a {
    println!("Hello, {}!", i);
}

Or even better:

if let a == Some(i) {
    println!("Hello, {}!", i);
}

Could someone please help me understand the rationale behind this?

Answer 1

The Rust syntax is

let Some(i) = a

because we are creating a new variable i and initializing it with the wrapped value in a. The operator = is for creating new variables. You have a pattern on the left hand side, and an expression on the right. All variables on the left, in the pattern, get initialized based on the corresponding values in the expression on the right.

The comparison operator == would not make sense here. To say

let Some(i) == a

would seem to return whether the expression

let Some(i)

is equal to the expression

a

When using == you expect the left and right hand sides to be complete expressions, that already have values, then you return whether they are equal. But that is not what we are doing in an if-let. When we use if-let we are creating a new variable. == only makes sense when the expressions on both sides of it can be evaluated.

Similarly, the expression

let a == Some(i)

is quite odd, because a already exists. We certainly are not creating a new variable a. And the same argument against using == as before applies, since i does not yet exist.

In summary we use = when creating a new variable and == for testing the equality of expressions (which if they have variables in them, such variables must already exist).