• Feature Name: if_while_or_patterns
• Start Date: 2017-10-16
• RFC PR: rust-lang/rfcs#2175
• Rust Issue: rust-lang/rust#48215

Summary

Enables "or" patterns for if let and while let expressions

#![allow(unused)]
fn main() {
enum E<T> {
    A(T), B(T), C, D, E, F
}

// Assume the enum E and the following for the remainder of the RFC:
use E::*;

let x = A(1);
let r = if let C | D = x { 1 } else { 2 };

while let A(x) | B(x) = source() {
    react_to(x);
}

enum ParameterKind<T, L = T> { Ty(T), Lifetime(L), }
use ParameterKind::*;

// Only possible when `L = T` such that `kind : ParameterKind<T, T>`.
let Ty(x) | Lifetime(x) = kind;

for Ty(x) | Lifetime(x) in ::std::iter::once(kind);
}

Motivation

While nothing in this RFC is currently impossible in Rust, the changes the RFC proposes improves the ergonomics of control

The following snippet

#![allow(unused)]
fn main() {
if let A(x) | B(x) = expr {
    do_stuff_with(x);
}
}

must be written as:

#![allow(unused)]
fn main() {
if let A(x) = expr {
    do_stuff_with(x);
} else if let B(x) = expr {
    do_stuff_with(x);
}
}

or, using match:

#![allow(unused)]
fn main() {
match expr {
    A(x) | B(x) => do_stuff_with(x),
    _           => {},
}
}

This way of using match is seen multiple

#![allow(unused)]
fn main() {
    fn fold<Acc, F>(self, init: Acc, mut f: F) -> Acc
        where F: FnMut(Acc, Self::Item) -> Acc,
    {
        let mut accum = init;
        match self.state {
            ChainState::Both | ChainState::Front => {
                accum = self.a.fold(accum, &mut f);
            }
            _ => { }
        }
        match self.state {
            ChainState::Both | ChainState::Back => {
                accum = self.b.fold(accum, &mut f);
            }
            _ => { }
        }
        accum
    }
}

which could have been written as:

#![allow(unused)]
fn main() {
    fn fold<Acc, F>(self, init: Acc, mut f: F) -> Acc
        where F: FnMut(Acc, Self::Item) -> Acc,
    {
        use ChainState::*;
        let mut accum = init;
        if let Both | Front = self.state { accum = self.a.fold(accum, &mut f); }
        if let Both | Back  = self.state { accum = self.b.fold(accum, &mut f); }
        accum
    }
}

This version is both shorter and clearer.

With while let, the ergonomics and in particular the readability

The following snippet

#![allow(unused)]
fn main() {
while let A(x) | B(x) = source() {
    react_to(x);
}
}

must currently be written as:

#![allow(unused)]
fn main() {
loop {
    match source() {
        A(x) | B(x) => react_to(x),
        _ => { break; }
    }
}
}

Another major motivation of the RFC is consistency with match.

To keep let and for statements

In addition

#![allow(unused)]
fn main() {
let Ok(index) | Err(index) = slice.binary_search(&x);
}

and we will get back the index in any case and continue on from there.

Guide-level explanation

RFC 2005, in describing

While the "sum" of all patterns in match must be irrefutable, or in other words: cover all cases, be exhaustive, this is not the case (currently) with if/while let, which may have a refutable pattern. This RFC does not change this.

The RFC only extends

For examples, see motivation.

Reference-level explanation

Grammar

文法

if let

The grammar

if_let_expr : "if" "let" pat '=' expr '{' block '}'
               else_tail ? ;

to:

if_let_expr : "if" "let" '|'? pat [ '|' pat ] * '=' expr '{' block '}'
               else_tail ? ;

while let

The grammar

while_let_expr : [ lifetime ':' ] ? "while" "let" pat '=' expr '{' block '}' ;

to:

while_let_expr : [ lifetime ':' ] ? "while" "let" '|'? pat [ '|' pat ] * '=' expr '{' block '}' ;

for

The expr_for grammar

expr_for : maybe_label FOR pat IN expr_nostruct block ;

to:

expr_for : maybe_label FOR '|'? pat ('|' pat)* IN expr_nostruct block ;

let statements

文

The statement

stmt ::= old_stmt_grammar
       | let_stmt_many
       ;

let_stmt_many ::= "let" pat_two_plus "=" expr ";"

pat_two_plus ::= '|'? pat [ '|' pat ] + ;

Syntax

文法

lowering

下方の、小文字の

The changes proposed in this RFC with respect to if let, while let, and for can be implemented

Meanwhile, let statements

Examples, if let

These examples are extensions on the if let RFC. Therefore, the RFC avoids

Source:

#![allow(unused)]
fn main() {
if let |? PAT [| PAT]* = EXPR { BODY }
}

Result:

#![allow(unused)]
fn main() {
match EXPR {
    PAT [| PAT]* => { BODY }
    _ => {}
}
}

Source:

#![allow(unused)]
fn main() {
if let |? PAT [| PAT]* = EXPR { BODY_IF } else { BODY_ELSE }
}

Result:

#![allow(unused)]
fn main() {
match EXPR {
    PAT [| PAT]* => { BODY_IF }
    _ => { BODY_ELSE }
}
}

Source:

#![allow(unused)]
fn main() {
if COND {
    BODY_IF
} else if let |? PAT [| PAT]* = EXPR {
    BODY_ELSE_IF
} else {
    BODY_ELSE
}
}

Result:

#![allow(unused)]
fn main() {
if COND {
    BODY_IF
} else {
    match EXPR {
        |? PAT [| PAT]* => { BODY_ELSE_IF }
        _ => { BODY_ELSE }
    }
}
}

Source

#![allow(unused)]
fn main() {
if let |? PAT [| PAT]* = EXPR {
    BODY_IF
} else if COND {
    BODY_ELSE_IF_1
} else if OTHER_COND {
    BODY_ELSE_IF_2
}
}

Result:

#![allow(unused)]
fn main() {
match EXPR {
    |? PAT [| PAT]* => { BODY_IF }
    _ if COND => { BODY_ELSE_IF_1 }
    _ if OTHER_COND => { BODY_ELSE_IF_2 }
    _ => {}
}
}

Examples, while let

The following example is an extension on the while let RFC.

Source

#![allow(unused)]
fn main() {
['label:] while let |? PAT [| PAT]* = EXPR {
    BODY
}
}

Result:

#![allow(unused)]
fn main() {
['label:] loop {
    match EXPR {
        PAT [| PAT]* => BODY,
        _ => break
    }
}
}

Examples, for

Assuming that the semantics of for is defined

#![allow(unused)]
fn main() {
for PAT in EXPR_ITER {
    BODY
}
}

into:

#![allow(unused)]
fn main() {
match IntoIterator::into_iter(EXPR_ITER) {
    mut iter => loop {
        let next = match iter.next() {
            Some(val) => val,
            None => break,
        };
        let PAT = next;
        { BODY };
    },
};
}

then the only thing that changes is that PAT may include | at the top level in the for loop and the desugaring as per the section

Desugaring let statements

文

with | in the top-level pattern

There continues to be an exhaustivity check in let statements,

This is a possible desugaring that a Rust compiler may do. While such a compiler may elect to implement

Source:

#![allow(unused)]
fn main() {
{
    // prefix of statements:
    stmt*
    // The let statement which is the cause for desugaring:
    let_stmt_many
    // the continuation / suffix of statements:
    stmt*
    tail_expr? // Meta-variable for optional tail expression without ; at end
}
}

Result

#![allow(unused)]
fn main() {
{
    stmt*
    match expr {
        pat_two_plus => {
            stmt*
            tail_expr?
        }
    }
}
}

For example, the following code:

#![allow(unused)]
fn main() {
{
    foo();
    bar();
    let Ok(index) | Err(index) = slice.binary_search(&thing);
    println!("{}", index);
    do_something_to(index)
}
}

can be desugared to

#![allow(unused)]
fn main() {
{
    foo();
    bar();
    match slice.binary_search(&thing) {
        Ok(index) | Err(index) => {
            println!("{}", index);
            do_something_to(index)
        }
    }
}
}

It can also be desugared to:

#![allow(unused)]
fn main() {
{
    foo();
    bar();
    let index = match slice.binary_search(&thing) {
        Ok(index) | Err(index) => index,
    }
    println!("{}", index);
    do_something_to(index)
}
}

(Both are equivalent)

Drawbacks

This adds more additions

Rationale and alternatives

代わりのもの、選択肢

This could simply not be done. Consistency with match is however on its own reason enough to do this.

It could be claimed that the if/while let RFCs already mandate this RFC, this RFC does answer that question and instead simply mandates it now.

Another alternative

Unresolved questions

The exact syntax

There are no unresolved questions.