Meaning of '&variable' in arguments/patter

Question

What does &variable mean when it is used in patterns or closure arguments?

for &code in self.exit_code.iter() { ... }

let mut new_seps = do seps.iter().fold(~[]) |result, &next| { ... }

Here we have &code and &next in for loop and closure definition. What do & sign in these mean? Why cannot we simply use code and next, without the ampersand? Is it related to ref qualifier in pattern matching? Is it related to & in self argument in trait implementations?

I couldn't find anything on this syntax neither in current Rust reference manual nor in tutorial. Currently I think this is some kind of implicit dereferencing (this follows from error message which appears if I omit & in the pattern), but I'm not sure.

Answer 1

It's a pattern match, "destructuring" something of type &T. That is, in

let &x = &1i; 

x has type int, and value 1. So it's actually the opposite to ref (which does what @KerrekSB is saying, ref x captures by reference rather than by value).

One can regard it as similar to

match returns_an_option() {
    Some(a) => { ... }
    None => { ... }
}

except the constructor of &T is &, not Some or None.

---

In this specific instance, I guess seps is a vector (the error you state indicates it's probably a &[&str]), so the .iter() returns an object that implements Iterator<& &str>, that is, it is an iterator over references to the elements of the vector (&str), thus, you need to dereference next somehow to get to the original &str. This can be done by & in a pattern match (as the code demonstrates) or with *next when it is used.

(Note that the & patterns only work with implicitly copyable types, as one cannot move ownership out from a reference/borrowed pointer (i.e. &T).)