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

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?

Solution 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.

Solution 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?