Update Indexing

Author: dumindu

content/en/docs/c2.borrowing.md

@@ -196,19 +196,17 @@ fn main() {
 // 💯 Using the `move` keyword forces the closure to take ownership: `let greet = move || println!("Hello, {name}!");`
 ```
 
-Using an index `[n]` on collections like `Vec` or `HashMap` involves an implicit shared borrow of the element. Example: The compiler effectively converts `a[0]` into `*a.index(0)`.
+Accessing an element from a slice or collection like `Vec` or `HashMap` for read-only access involves the [`Index` trait](https://doc.rust-lang.org/std/ops/trait.Index.html). The compiler implicitly converts `a[0]` into `*a.index(0)`, which involves an implicite shared borrow of the collection.
 
 ```rust
-fn main() {
-    let a = vec![1, 2, 3]; // Vector of a Copy type
-    let b = vec!["Apple".to_string(), "Pear".to_string()]; // Vector of a non-Copy/ move type
-
-    // 💡 a[0] and b[0] are references to the relevant elements of the vectors
+// Two concepts in the example: 1. Implicite shared reference; 2. Assigning Copy types/ non-Copy types to a new variable.
 
-    let c = a[0]; // A copy of a[0] is assigned to `c: i32`
+fn main() {
+    let a = vec![1, 2, 3]; // 💡 contains Copy types
+    let b = vec!["Apple".to_string(), "Pear".to_string()]; // 💡 contains non-Copy/ move types
 
-    // Without .clone(), b[0] would attempt to move into `d: String`
-    // ⭐️ Since this would destroy the original element inside the vector, the Rust borrow checker will not let it compile
+    let c = a[0]; // a[0] access the element via a shared reference + Copy the element into `c: i32`
+    // b[0] access the element via a shared reference + manually call `.clone()` as non-Copy types move/ destroy the original data
     let d = b[0].clone();
 
     println!("{c} {d}");
@@ -266,6 +264,7 @@ fn borrow_struct_to_assign(p: &Person) {
     println!("{a} {b}");
 }
 
+// ⭐️ Each reference is scoped to the function call.
 // 👨‍🏫 Try remove `.clone()`. The borrow checker will not let it compile.
 // 💥 cannot move out of `p.name` which is behind a shared reference
 ```
@@ -325,7 +324,7 @@ fn main() {
 }
 ```
 
-Using an index `[n]` on collections like `Vec` or `HashMap` to modify an element involves an implicit mutable borrow. Example: The compiler effectively converts `a[0]` into `*a.index_mut(0)`.
+Accessing an element from a slice or collection like `Vec` for mutable access involves the [`IndexMut` trait](https://doc.rust-lang.org/std/ops/trait.IndexMut.html). The compiler implicitly converts `a[0]` into `*a.index_mut(0)`, which involves an implicit mutable borrow of the collection.
 
 ```rust
 fn main() {