Why does &v[1] + &v[2] have the same result as v[1] + v[2] in Rust?

Question

I'm learning about ownership and borrowing.

The difference between borrow1 and borrow2 is the usage of & while printing in borrow2:

fn borrow1(v: &Vec<i32>) {
    println!("{}", &v[10] + &v[12]);
}

fn borrow2(v: &Vec<i32>) {
    println!("{}", v[10] + v[12]);
}

fn main() {
    let mut v = Vec::new();

    for i in 1..1000 {
        v.push(i);
    }

    borrow1(&v);
    println!("still own v {} , {}", v[0], v[1]);

    borrow2(&v);
    println!("still own v {} , {}", v[0], v[1]);
}

Why do they give the same output, even though borrow1 doesn't have &?

[burrow](http://www.dictionary.com/browse/burrow): *a hole or tunnel in the ground made by a rabbit, fox, or similar animal for habitation and refuge*. [borrow](http://www.dictionary.com/browse/borrow): *to take or obtain with the promise to return the same or an equivalent*. — Shepmaster, Jan 07 '18 at 23:09
Note that you can write this `let v: Vec<_> = (1..10).collect();` instead of the loop. — Boiethios, Jan 08 '18 at 09:08

Shepmaster · Accepted Answer · 2018-01-14T03:15:42.863

The index operator ([]) for a Vec<T> returns a T. In this case, that's an i32. Thus v[0] returns an i32 and &v[0] returns an &i32:

let a: i32 = v[0];
let b: &i32 = &v[0];

v[0] only works because i32 implements Copy.

i32 has implemented Add for both the (left-hand side, right-hand-side) pairs of (i32, i32) and (&i32, &i32). The two implementations add values in the same way, so you get the same result.

Why does &v[1] + &v[2] have the same result as v[1] + v[2] in Rust?

1 Answers1

Linked