Rfcs: Allow `if <cond> { ... } else match { ... }`

[Diggsey]

We allow else if so it's a pretty natural extension to support else match too. In fact I've often forgotten that this is not supported...

Example:

fn main() {
    let x = 1;
    let y = 2;
    if x == 2 {
        // Do something
    } else match y {
        1 => {},
        _ => {}
    }
}

[alex-dukhno]

This was proposed some time ago see https://github.com/rust-lang/rfcs/pull/2901

[Diggsey]

Ah I didn't find this when I was looking for existing proposals.

One reason why this makes sense for match is that if let is normally documented as syntax sugar for a two-arm match statement, but we allow else if let ... and not else match ... which seems inconsistent...

In general, I would be in favour of allowing any scope-introducing statement (while, loop, for, etc.) to follow an else directly, although else match seems like a good first step.

[workingjubilee]

As mentioned there, (else) if let is viable as a single branch always. else match becomes incoherent with the ordinary if { } else if { } else { } syntax because it must be the terminating branch. This introduces more special casing in parsing so while it may add one kind of consistency it reduces other kinds of consistency, and as such is not a clearly desirable addition and needs a stronger argument for it.

[SOF3]

What about this?

fn main() {
    let x = 1;
    let y = 2;
    match y {
        _ if x == 2 => do_something(),
        1 => {},
        _ => {}
    }
}

[burdges]

Yes, that's idiomatic at least when the first y matches anything more than _.

Imho, we should complicate syntax to prevent rightward drift because rightward drift can always be addressed by bracket conventions.

if foo {
    ...
} else if bar {
    .. 
} else { match baz {
    .. => ..
} }

This is not the greatest example, but bracket conventions usually improve readability considerably, like the double bracketing makes the closure more visible while avoiding rightward drift in

foo(|x,y| {
    ...
} );