X-Git-Url: https://git.ralfj.de/rust-101.git/blobdiff_plain/38318e759c8aae48e68e413856289eb436a15b08..76e70189b58f06dc3beaf8714fb5fdd998b1c8a0:/src/part04.rs?ds=inline

diff --git a/src/part04.rs b/src/part04.rs
index 375ef9f..dc116ee 100644
--- a/src/part04.rs
+++ b/src/part04.rs
@@ -50,9 +50,9 @@ fn ownership_demo() {
 //@ we wanted! Can't we somehow give `vec_min` access to the vector, while retaining ownership of it?
 //@ 
 //@ Rust calls this *a reference* the vector, and it considers references as *borrowing* ownership. This
-//@ works a bit like borrowing does in the real world: If you borrow a book to your friend, your friend
+//@ works a bit like borrowing does in the real world: If your friend borrows a book from you, your friend
 //@ can have it and work on it (and you can't!) as long as the book is still borrowed. Your friend could
-//@ even borrow the book to someone else. Eventually however, your friend has to give the book back to you,
+//@ even lend the book to someone else. Eventually however, your friend has to give the book back to you,
 //@ at which point you again have full control.
 //@ 
 //@ Rust distinguishes between two kinds of references. First of all, there's the *shared* reference.
@@ -88,7 +88,7 @@ fn shared_ref_demo() {
     vec_min(&v);
     println!("The first element is: {}", *first);
 }
-//@ What's going on here? First, `&` is how you borrow ownership to someone - this operator creates a shared reference.
+//@ What's going on here? First, `&` is how you lend ownership to someone - this operator creates a shared reference.
 //@ `shared_ref_demo` creates three shared references to `v`:
 //@ The reference `first` begins in the 2nd line of the function and lasts all the way to the end. The other two
 //@ references, created for calling `vec_min`, only last for the duration of that respective call.
@@ -99,7 +99,7 @@ fn shared_ref_demo() {
 
 // ## 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 - there is no aliasing. It is thus always safe to perform mutation through such a reference.
+//@ 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.
 
 //@ As an example, consider a function which increments every element of a vector by 1.