Nsryjdtyk

I am playing around with Rust references:

fn main() {

    let str = String::from("Hallo");

    let &x = &str;

}

This produces the following error:

error[E0507]: cannot move out of borrowed content

 --> src/main.rs:3:9

  |

3 |     let &x = &str;

  |         ^-

  |         ||

  |         |hint: to prevent move, use `ref x` or `ref mut x`

  |         cannot move out of borrowed content

What is going on here?

Adding to wiomoc's answer: depending on what language(s) you've previously known, variable declaration in Rust might be a little different. Whereas in C/C++ you explicitly have to declare that you want a pointer/reference variable:

int *p = &other_int;

In Rust it's enough to just use let, so the above would in Rust be

let p = &other_int;

and when you write

let &s = &string;

It pattern-matches that, so the Rust compiler reads it roughly as "I know I have a reference, and I want to bind whatever it is referring to to the name p". If you're not familiar with pattern-matching, a more obvious example (that works in Rust as well) would be

let point = (23, 42);

let (x, y) = point;

The second line unpacks the right-hand side to match the left-hand side (both are tuples of two values) and binds the variable names on the left to the values at the same position in the structure on the right. In the case above, it's less obvious that it's matching your "structural description".

The result of let &x = &str;, i.e. "I know &str is a reference, please bind whatever it refers to to the variable x" means that you're trying to have x be the same as str, when at that line all you have is a borrowed reference to str. That's why the compiler tells you you can't create an owned value (which x would be, because it's not being created as a reference) from a reference.

You dont need that &at let x

let str = String::from("Hallo");

let x = &str;

Or if you want to declare the type manually

let string = String::from("Hallo");

let x: &str = &string;