From ef190d9e766410208df1bb2108e93b7892f8a8a8 Mon Sep 17 00:00:00 2001
From: Tanish-Eagle <ta.shrivastava@gmail.com>
Date: Wed, 20 Apr 2022 17:27:21 +0530
Subject: [PATCH] Fixed mistakes and missing semicolon in array

---
 en/src/compound-types/array.md | 42 +++++++++++++++++-----------------
 1 file changed, 21 insertions(+), 21 deletions(-)

diff --git a/en/src/compound-types/array.md b/en/src/compound-types/array.md
index 92104e1..d884a3b 100644
--- a/en/src/compound-types/array.md
+++ b/en/src/compound-types/array.md
@@ -1,26 +1,26 @@
 # Array
-The type of array is `[T; Lengh]`, as you can see, array's lengh is part of their type signature. So their length must be known at compile time.
+The type of array is `[T; Length]`, as you can see, array's length is part of their type signature. So their length must be known at compile time.
 
-For example, you cant initialized an array as below:
+For example, you cant initialize an array like below:
 ```rust
 fn init_arr(n: i32) {
     let arr = [1; n];
 }
 ```
 
-This will cause an error, because the compile have no idea of the exact size of the array in compile time.
+This will cause an error, because the compiler has no idea of the exact size of the array at compile time.
 
 1. 🌟 
 ```rust,editable
 
 fn main() {
-    // fill the blank with proper array type
+    // Fill the blank with proper array type
     let arr: __ = [1, 2, 3, 4, 5];
 
-    // modify below to make it work
+    // Modify the code below to make it work
     assert!(arr.len() == 4);
 
-    println!("Success!")
+    println!("Success!");
 }
 ```
 
@@ -28,16 +28,16 @@ fn main() {
 ```rust,editable
 
 fn main() {
-    // we can ignore parts of the array type or even the whole type, let the compiler infer it for us
+    // We can ignore parts of the array type or even the whole type, let the compiler infer it for us
     let arr0 = [1, 2, 3];
     let arr: [_; 3] = ['a', 'b', 'c'];
     
-    // fill the blank
-    // Arrays are stack allocated, `std::mem::size_of_val` return the bytes which array occupies
-    // A char takes 4 byte in Rust: Unicode char
+    // Fill the blank
+    // Arrays are stack allocated, `std::mem::size_of_val` returns the bytes which an array occupies
+    // A char takes 4 bytes in Rust: Unicode char
     assert!(std::mem::size_of_val(&arr) == __);
 
-    println!("Success!")
+    println!("Success!");
 }
 ```
 
@@ -46,13 +46,13 @@ fn main() {
 ```rust,editable
 
 fn main() {
-    // fill the blank
+    // Fill the blank
     let list: [i32; 100] = __ ;
 
     assert!(list[0] == 1);
     assert!(list.len() == 100);
 
-    println!("Success!")
+    println!("Success!");
 }
 ```
 
@@ -60,10 +60,10 @@ fn main() {
 ```rust,editable
 
 fn main() {
-    // fix the error
+    // Fix the error
     let _arr = [1, 2, '3'];
 
-    println!("Success!")
+    println!("Success!");
 }
 ```
 
@@ -73,28 +73,28 @@ fn main() {
 fn main() {
     let arr = ['a', 'b', 'c'];
     
-    let ele = arr[1]; // only modify this line to make the code work!
+    let ele = arr[1]; // Only modify this line to make the code work!
 
     assert!(ele == 'a');
 
-    println!("Success!")
+    println!("Success!");
 }
 ```
 
 6. 🌟 Out of bounds indexing causes `panic`.
 ```rust,editable
 
-// fix the error
+// Fix the error
 fn main() {
     let names = [String::from("Sunfei"), "Sunface".to_string()];
     
-    // `get` returns an Option<T>, it's safe to use
+    // `Get` returns an Option<T>, it's safe to use
     let name0 = names.get(0).unwrap();
 
-    // but indexing is not safe
+    // But indexing is not safe
     let _name1 = &names[2];
 
-    println!("Success!")
+    println!("Success!");
 }
 
 ```