RFC: Allow copyless destructuring of tuples

[erickt]

Destructuring a tuple now warns on an implicit copy. For example, this code:

fn main() {
    let x = [("a", "b")];
    for x.each { |ab|
        let (a, b) = ab;
        #error("%? : %?", a, b);
    }
}

Warns with this message:

test.rs:4:21: 4:23 warning: implicitly copying a non-implicitly-copyable value
test.rs:4         let (a, b) = ab;

To fix it, we need to change the destructure to let (a, b) = copy ab;. The copy isn't needed for situations like this though. This code could be replaced with an alt-block to avoid the copy:

fn main() {
    let x = [("a", "b")];
    for x.each { |ab|
        alt ab {
          (a, b) { #error("%? : %?", a, b) }
        }
    }
}

But then that just adds more indention creep. Ideally rust would infer the usage and not require a copy, but if that's not possible, nmatsakis mentioned we may be able to create region pointers when destructuring. He suggested a syntax like let (&a, &b) = ab;. This syntax could then also be used in alt-blocks to keep the destructuring syntax consistent.

[nikomatsakis]

I would prefer a more general proposal. That is, something like this: in patterns, a reference to a variable means "copy out" and a reference preceded by & means "take a pointer". So:

alt opt {
    some(x) { ... }  // copies x 
    none { ... }
} 

whereas

alt opt {
    some(&x) { ... }  // x is a pointer into opt
    none { ... }
} 

this would apply equally to let patterns. let (a, b) = pair would copy out, whereas let (&a, &b) = pair would take pointers.

I think this hinges on &P not being a valid pattern form, though, which implies that region pointers need a different sigil, since I think it makes sense to have a pattern form that matches against region pointers. My thought was that region pointers ought to be *P and unsafe pointers being *unsafe P.

[pcwalton]

You can already move out of tuples when you destructure them. What's actually biting you here is the wily argument modes. The reason the implicit copy is happening is that, in your lambda block, ab is actually by-reference mode. Thus move is disallowed and you're getting the warning about the implicit copy. If ab were by-copy or by-move, then you would be able to destructure without copying as you would expect.

The right way to fix this is, as Niko suggested above, let (&a, &b) = pair, as well as getting rid of argument modes so this whole thing will be less confusing.

[pcwalton]

Closing this as not-a-bug.