Can I destructure a tuple without binding the result to a new variable in a let/match/for statement?

Question

I'd like to destructure a tuple and assign part of the result to a new variable and assign another part of the result to an existing.

The following code illustrates the intent (it's a dumb example which results in an infinite loop printing [0]):

fn main() {     let mut list = &[0, 1, 2, 3][..];     while !list.is_empty() {         let (head, list) = list.split_at(1);         // An obvious workaround here is to introduce a new variable in the above         // let statement, and then just assign it to list.         println!("{:?}", head);     } } 

This code creates a new variable list instead of reassigning it.

If I change the code to the following (to avoid the let that introduces the new list variable), it doesn't compile:

fn main() {     let mut list = &[0, 1, 2, 3][..];     while !list.is_empty() {         let head;         (head, list) = list.split_at(1);         println!("{:?}", head);     } } 

Compilation error:

error[E0070]: invalid left-hand side of assignment  --> src/main.rs:5:22   | 5 |         (head, list) = list.split_at(1);   |         ------------ ^   |         |   |         cannot assign to this expression   | 

Is there a way to do this, or can destructuring only be used in let, match, and for statements?

Answer 1

No.

Destructuring is something you can only do with patterns; the left-hand side of an assignment is not a pattern, hence you can't destructure-and-assign.

See proto-RFC 372 (Destructuring assignment) which discusses the possibility of adding this feature.

Answer 2

Nightly Rust has feature(destructuring_assignment), which allows your original attempt to compile as-is:

#![feature(destructuring_assignment)]  fn main() {     let mut list = &[0, 1, 2, 3][..];     while !list.is_empty() {         let head;         (head, list) = list.split_at(1);         println!("{:?}", head);     } } 

[0] [1] [2] [3] 

---

However, I'd solve this using stable features like slice pattern matching, which avoids the need for the double check in split_at and is_empty:

fn main() {     let mut list = &[0, 1, 2, 3][..];      while let [head, rest @ ..] = list {         println!("{:?}", head);         list = rest;     } } 

See also:

• How to swap two variables?