Rust: Tracking issue for eRFC 2497, "if- and while-let-chains, take 2"

Created on 24 Aug 2018 · 12Comments · Source: rust-lang/rust

This is a tracking issue for the eRFC "if- and while-let-chains, take 2" (rust-lang/rfcs#2497).
For the tracking issue for the immediate edition changes, see #53668.

Steps:

[ ] Implement the RFC (cc @rust-lang/compiler -- can anyone write up mentoring instructions?)
[ ] Adjust documentation (see instructions on forge)
[ ] Stabilization PR (see instructions on forge)

Unresolved questions:

[ ] [The final syntax](https://github.com/rust-lang/rfcs/blob/master/text/2497-if-let-chains.md#the-final-syntax)
[ ] [Should temporary and irrefutable lets without patterns be allowed in some form?](https://github.com/rust-lang/rfcs/blob/master/text/2497-if-let-chains.md#irrefutable-let-bindings-after-the-first-refutable-binding)
[ ] [Chained if lets inside match arms](https://github.com/rust-lang/rfcs/blob/master/text/2497-if-let-chains.md#chained-if-lets-inside-match-arms)

Collected issues:

Implementation history:

B-RFC-approved C-tracking-issue F-let_chains T-lang

Source

Centril

👍79 🚀2 ❤2

Most helpful comment

(not sure this is the right place for this, but I don't think we have anything else opened for "pattern matching expressions" discussion).

I've just noticed that Java is getting pattern matching along the lines proposed in https://github.com/rust-lang/rfcs/issues/929#issuecomment-285602496. That is, control-flow sensitive scoping and patterns on the right are now almost Java-level proven and trusted language design choices.

matklad on 25 Jan 2020

👍9

All 12 comments

I'm working on implementing this in a 3+ PR step fashion based on discussions with @oli-obk.

Centril on 11 Mar 2019

👍7

for the record, the discussed step list is

remove if from HIR and make lowering emit a match
remove if let from AST and instead have a let expression
"do the rest of the work" (might get split up further).

oli-obk on 11 Mar 2019

❤4

I can't imagine 3 would be a particularly large step (enough to merit splitting), but 3 steps sounds fair enough.

alexreg on 11 Mar 2019

@Centril I'm really jazzed about this feature, lmk if there is any work I can help with.

estk on 20 May 2019

@estk :) The work is pretty non-parallelizable at the moment; However, once https://github.com/rust-lang/rust/pull/60861 lands you may want to take a look at https://github.com/rust-lang/rust/issues/60336.

Centril on 20 May 2019

Question worth discussing: This introduces let as something _like_ an expression in the AST.

Do we plan to make it a true expression? As in, will $e:expr match let Pat(..) = foo in macros? This does not mean that it will _work_ everywhere (as @centril correctly points out, $t:ty matches impl Trait, but it's only allowed in certain positions in the AST), it just means that macros will be able to match on it. They may error further down the pipeline if it gets used outside of an if.

This is technically a breaking behavior change; a macro with a fallthrough to let $p:pat = $e:expr will suddenly start behaving differently.

Manishearth on 26 May 2019

@Manishearth I thought that you can't probe whether something parses as an AST fragment in macro_rules macros, only tokens (this includes $i:ident, $l:lit, etc.).
That is, I expected the first expr/pat/stmt/block/item/etc. that is reached to be final.
But I'm wrong, and this is either behavior introduced in the past couple years, or I was just confused.

eddyb on 28 May 2019

this is either behavior introduced in the past couple years

This is https://github.com/rust-lang/rust/pull/42913 if I'm not mistaken, almost 2 years ago.
One token lookahead is used to reject alternatives that "obviously don't fit".

petrochenkov on 29 May 2019

👍1

(not sure this is the right place for this, but I don't think we have anything else opened for "pattern matching expressions" discussion).

matklad on 25 Jan 2020

👍9

any actual syntax for this in nightly rust? just cannot type it to work.

! Compiling of exercises/conversions/from_into.rs failed! Please try again. Here's the output:
error: `let` expressions are not supported here
  --> exercises/conversions/from_into.rs:44:33
   |
44 |         if (parts.len() == 2 && let Some(n) = name && let Some(Ok(a))= age) {
   |                                 ^^^^^^^^^^^^^^^^^^
   |
   = note: only supported directly in conditions of `if`- and `while`-expressions
   = note: as well as when nested within `&&` and parenthesis in those conditions

not nice

if parts.len() == 2 { if let Some(n) = name { if let Some(Ok(a)) = age { 
            return Person{name: n.to_owned().to_string(),  age : a,}; 
        }}}