//@ that was created before calling `vec_min` remains valid.
// ## Unique, mutable references
-
//@ There is a second way to borrow something, a second kind of reference: The *mutable reference*.
//@ This is a reference that comes with the promise that nobody else has *any kind of access* to
//@ the referee - in contrast to shared references, there is no aliasing with mutable references.
-//@ It is thus always safe to perform mutation through such a reference.
-//@ Because there cannot be another reference to the same data, we could also call it a *unique* reference, but that is not their official name.
+//@ It is thus always safe to perform mutation through such a reference. Because there cannot be
+//@ another reference to the same data, we could also call it a *unique* reference, but that is not
+//@ their official name.
//@ As an example, consider a function which increments every element of a vector by 1.
-//@ The type `&mut Vec<i32>` is the type of mutable references to `vec<i32>`. Because the reference
+//@ The type `&mut Vec<i32>` is the type of mutable references to `Vec<i32>`. Because the reference
//@ is mutable, we can use a mutable iterator, providing mutable references to the elements.
fn vec_inc(v: &mut Vec<i32>) {
for e in v.iter_mut() {
vec_inc(&mut v);
/* println!("The first element is: {}", *first); */ /* BAD! */
}
-
//@ `&mut` is the operator to create a mutable reference. We have to mark `v` as mutable in order
//@ to create such a reference: Even though we completely own `v`, Rust tries to protect us from
//@ accidentally mutating things.