if-let patterns should be as expressive as match patterns

[Munksgaard]

Right now, you can do this

enum Foo {
  One(u8),
  Two(u8),
  Three
}
use Foo::*;

fn main () {
    let x = One(42);
    match x {
        One(n) | Two(n) => {
            println!("Got one or two with val: {}", n);
        }
        _ => {}
    }
}

but not this

enum Foo {
  One(u8),
  Two(u8),
  Three
}
use Foo::*;

fn main () {
    let x = One(42);
    if let One(n) | Two(n) = x {
        println!("Got one or two with val: {}", n);
    }
}

The same goes for pattern guards.

The RFC for if-let proposes the if-let notation pretty much as syntactic sugar for a match block with an empty arm at the end. However, if-let doesn't allow matching on pattern guards and multiple patterns. Extending the if-let notation to allow guards and multiple patterns feel like a natural extension to the current functionality with plenty of use cases.

I've started on an actual rfc, but there might be some parsing and syntactic details we'd have to figure out before it makes sense to finish it. For instance, if let Some(n) = x if n = 0 looks weird at best.

On the positive side, adding support for guards and multiple patterns shouldn't break anything.

cc @Manishearth

[lifthrasiir]

Actually this relates to another issue: Why don't we allow alternations (|) in any patterns, not just top-level patterns in match?

[Manishearth]

@lifthrasiir rust-lang/rust#14516 rust-lang/rust#17180 #99

[Munksgaard]

@lifthrasiir It certainly does, but I feel like many of the issues that pertain to #99 don't apply here, since if-let is really just sugaring for a match statement.

[Manishearth]

I guess the only changes we need here are to allow | in the grammar and extend if let parsing to produce ExprMatches with multiple Pats per arm. No change to the AST required (yay).

[Manishearth]

My bad, we'll need to make ExprIfLet take a Vec<Pat>

[Munksgaard]

This branch adds support for multiple patterns in both if-let and while-let statements. If we want to do the same for guards, we'll probably need to discuss what syntax we want.

https://github.com/Munksgaard/rust/tree/if-while-let-multiple-patterns

[Manishearth]

I don't think if let should support guards. if let Some(a) == bar && baz() {} seems like a reasonable syntax however. But I'm wary of supercharging if let, it's just a sugar after all.

[Munksgaard]

I don't really see any other reasons beside the syntax for not letting if let support guards. As you said, it's just sugar, so any guards would translate directly into a match guard.

As you're saying though, the syntax could get really ugly.

Wouldn't if let Some(a) == bar && baz() {} introduce ambiguity? For instance: if let true = x && false { }

[Manishearth]

Yep. Another reason to avoid it :)

[pcwalton]

I've wanted guards in if let multiple times. This is an easy backwards compatible change. +1 from me.

For some reason while let ... if ... { ... } strikes me as a little brain-twisting at first, but the semantics are clear.

[Munksgaard]

@pcwalton:
Yeah, I'm mostly for that syntax as well, no ambiguities, even though it's a bit of an eyesore.

[mdinger]

#929 is similar to this bug but it focuses on on adding && instead of |. It uses || because of similarity to if A || B although it was only minor because I thought || might be more unlikely to be accepted.

[mdinger]

My last comment was a mistake. They do look slightly similar but they are completely different types of proposals.