Add modifications from review

Author: romain-at-adacore

courses/rust_essentials/050_tuples_and_arrays/01_arrays.rst

@@ -17,12 +17,12 @@ What Is an Array?
 Basics
 --------------------
 
-- Allocated on the stack, they're fast!
+- Allocated on the stack - they're fast!
 - *Size* is **fixed** and defined at **compile-time**
 - *Length* of an array is part of its type
-  - :rust:`[T;N]` holds :rust:`N` elements of type T
+  - :rust:`[T;N]` holds :rust:`N` elements of type :rust:`T`
   - :rust:`[u8;3]` and :rust:`[u8;4]` are considered two different types
-- Indexes start at :rust:`0` (Range is :rust:`0` to :rust:`N-1`)
+- Index starts at :rust:`0` (range is :rust:`0` to :rust:`N-1`)
 
 .. code:: rust
 
@@ -32,15 +32,15 @@ Basics
 
 .. note::
 
-   Reminder: :rust:`mut` is required for modification
+   Remember, :rust:`mut` is required for modification
 
 -----------------------------------
 Safety and Initialization
 -----------------------------------
 
 **Safety**
 
-  - Compile-time and runtime **out-of-bounds checks**
+  - Compile-time and run-time **out-of-bounds checks**
   - Accessing an element beyond the defined length will cause a *panic*
     - A *panic* is a form of program termination
 
@@ -56,33 +56,44 @@ Safety and Initialization
   let bools    = [true, false, true];      // Boolean literals
 
 * Or using *array repeat expression* :rust:`[value; N]`:
-  * With size *N*, known at compile-time
+  * With size :rust:`N`, known at compile-time
   * Where every element is *value*
 
 .. code:: rust
 
   let elements: [i8; 5] = [0; 5];
 
 * Assignment is **not** limited to literals
-  * Not restricted to hard-coded values
   * Can use variables, function calls, or expressions
 
 -------------------
 Iteration
 -------------------
 
-  - :rust:`for` statement natively supports iterating over arrays
+* :rust:`for` statement natively supports iterating over arrays
 
-.. code:: rust
+* Given an array
+
+  .. code:: rust
 
     let primes = [2, 3, 5, 7, 11, 13, 17];  
+
+* Iteration by value would look like
+
+  .. code:: rust
+
     for prime in primes {
-        // ... do something
+      println!("{}", prime);    
     }
 
+* While index-based looping would look like
+
+  .. code:: rust
+
     for ii in 0..primes.len() {
-        // ... do something, using primes[ii]
+      println!("{}", primes[ii]);
     }
+
 .. container:: speakernote
 
    Arrays do not implement the default Display trait ({}).

courses/rust_essentials/050_tuples_and_arrays/02_tuples.rst

@@ -6,13 +6,14 @@ Tuples
 Basics
 --------------------
 
-  - Groups together values of **different types**
+  - Group together values of **different types**
   - Like arrays, have a **fixed length**
-  - Fields are accessed via dot notation by their index, starting from :rust:`0`
+  - Elements are accessed via dot notation by their index
+    - Starting from :rust:`0`
 
 .. code:: rust
 
    // Tuple with an i8 and a bool
    let alien_report: (i8, bool) = (3, false);
    println!("Number of tentacles: {}", alien_report.0); 
-   println!("...is the creature hostile: {}", alien_report.1);
+   println!("Hostile? {}", alien_report.1);

courses/rust_essentials/050_tuples_and_arrays/99_summary.rst

@@ -18,9 +18,14 @@ What We Covered
   - Fields are accessed via dot notation followed by their index
     - Starting from :rust:`0`
 
+-----------------------------
+What We Covered (Continued)
+-----------------------------
+
 - **Patterns and Destructuring**
   - Used for clarity, simplicity and skipping unneeded values
   - Irrefutable patterns are patterns guaranteed to match the structure 
-  - Skip specific element using (:rust:`_`) and multiple elements using (:rust:`..`)
+  - Skip an element using (:rust:`_`) and multiple elements using (:rust:`..`)
   - Destructuring can be used as an assignment operation
   - Use a pattern within a pattern to destructure an array of arrays
+