Fixing minor grammar issues and typo issues

Author: dumindu

source/docs/b1.vectors.md

@@ -1,28 +1,28 @@
 title: Vectors
 ---
 
-If you remember, array is a  fixed-size list of elements, of same data type. Even with mut, its element count can not be changed. A vector is kind of **a re-sizable array** but **all elements must be in the same type**.
+If you remember, the array is a fixed-size list of elements, of the same data type. Even with mut, its element count cannot be changed. A vector is kind of **a re-sizable array** but **all elements must be in the same type**.
 
-⭐️ It’s a generic type, written as **`Vec<T>`** . T can have any type, ex. The type of a Vec of i32s is `Vec<i32>`. Also, Vectors always allocate their data in dynamically allocated heap.
+⭐️ It’s a generic type, written as **`Vec<T>`** . T can have any type, ex. The type of a Vec of i32s is `Vec<i32>`. Also, Vectors always allocate their data in a dynamically allocated heap.
 
 ### Create empty vector
 
 ```rust
-let mut a = Vec::new(); //1.with new() keyword
-let mut b = vec![]; //2.using the vec! macro
+let mut a = Vec::new(); //1.With new() keyword
+let mut b = vec![]; //2.Using the vec! macro
 ```
 
 ### Create with data types
 
 ```rust
 let mut a2: Vec<i32> = Vec::new();
 let mut b2: Vec<i32> = vec![];
-let mut b3 = vec![1i32, 2, 3];//sufixing 1st value with data type
+let mut b3 = vec![1i32, 2, 3];//Sufixing 1st value with data type
 
 let mut b4 = vec![1, 2, 3];
 let mut b5: Vec<i32> = vec![1, 2, 3];
 let mut b6  = vec![1i32, 2, 3];
-let mut b7 = vec![0; 10]; //ten zeroes
+let mut b7 = vec![0; 10]; //Ten zeroes
 ```
 
 ### Access and change data
@@ -32,7 +32,7 @@ let mut b7 = vec![0; 10]; //ten zeroes
 let mut c = vec![5, 4, 3, 2, 1];
 c[0] = 1;
 c[1] = 2;
-//c[6] = 2; can't assign values this way, index out of bounds
+//c[6] = 2; Cannot assign values this way, index out of bounds
 println!("{:?}", c); //[1, 2, 3, 2, 1]
 
 //push and pop
@@ -55,13 +55,13 @@ e.push(11);
 ```
 
 ⭐️ Mainly a vector represent 3 things,
-- a **pointer** to the data
+- A **pointer** to the data
 - **No of elements** currently have(**length**)
-- **capacity** (Amount of space allocated for any future elements). 
+- **Capacity** (Amount of space allocated for any future elements). 
 
 If the length of a vector exceeds its capacity, its capacity will be increased automatically. But its elements will be reallocated(which can be slow). So always use Vec::**with_capacity** whenever it’s possible.
 
-> 💡 **String** data type is a UTF-8 encoded vector. But you can not index into a String because of encoding.
+> 💡 The **String** data type is a UTF-8 encoded vector. But you can not index into a String because of encoding.
 
 
 💯 Vectors can be used with iterators in three ways,

source/docs/b2.structs.md

@@ -1,26 +1,26 @@
 title: Structs
 ---
 
-⭐️ Structs are used to **encapsulate related properties** into one unified datatype.
+⭐️ Structs are used to **encapsulate related properties** into one unified data type.
 
 💡 By convention, the name of the struct starts with a capital letter and follows **CamelCase**.
 
 There are 3 variants of structs,  
 1. **C-like structs**
-  * one or more comma separated name:value pairs
-  * brace-enclosed  list
-  * similar to classes \(without its methods\) in OOP languages
-  * because fields have names, we can access them through dot notation
+  * One or more comma-separated name:value pairs
+  * Brace-enclosed list
+  * Similar to classes \(without its methods\) in OOP languages
+  * Because fields have names, we can access them through dot notation
 
 2. **Tuple structs**
-  * one or more comma separated values
-  * parenthesized list like tuples
-  * looks like a named tuples
+  * One or more comma-separated values
+  * A parenthesized list like tuples
+  * Looks like a named tuples
 
 3. **Unit structs**
-  * a struct with no members at all
-  * it defines a new type but it resembles an empty tuple, \(\)
-  * rarely in use,  useful with generics
+  * A struct with no members at all
+  * It defines a new type but it resembles an empty tuple, \(\)
+  * Rarely in use, useful with generics
 
 ⭐️ When regarding OOP in Rust, attributes and methods are placed separately on **structs** and **traits**. Structs contain only attributes, traits contain only methods. They are getting connected via **impls**.
 
@@ -37,30 +37,30 @@ struct Color {
 }
 
 fn main() {
-  // creating an instance
+  // Creating an instance
   let black = Color {red: 0, green: 0, blue: 0};
 
-  // accessing its fields using dot notation
+  // Accessing its fields using dot notation
   println!("Black = rgb({}, {}, {})", black.red, black.green, black.blue); //Black = rgb(0, 0, 0)
 
-  // structs are immutable by default, use `mut` to make it mutable but doesn't support field level mutability
+  // Structs are immutable by default, use `mut` to make it mutable but doesn't support field level mutability
   let mut link_color = Color {red: 0,green: 0,blue: 255};
   link_color.blue = 238;
   println!("Link Color = rgb({}, {}, {})", link_color.red, link_color.green, link_color.blue); //Link Color = rgb(0, 0, 238)
 
-  // copy elements from another instance
+  // Copy elements from another instance
   let blue = Color {blue: 255, .. link_color};
   println!("Blue = rgb({}, {}, {})", blue.red, blue.green, blue.blue); //Blue = rgb(0, 0, 255)
 
-  // destructure the instance using a `let` binding, this will not destruct blue instance
+  // Destructure the instance using a `let` binding, this will not destruct blue instance
   let Color {red: r, green: g, blue: b} = blue;
   println!("Blue = rgb({}, {}, {})", r, g, b); //Blue = rgb(0, 0, 255)
 
-  // creating an instance via functions & accessing its fields
+  // Creating an instance via functions & accessing its fields
   let midnightblue = get_midnightblue_color();
   println!("Midnight Blue = rgb({}, {}, {})", midnightblue.red, midnightblue.green, midnightblue.blue); //Midnight Blue = rgb(25, 25, 112)
 
-  // destructure the instance using a `let` binding
+  // Destructure the instance using a `let` binding
   let Color {red: r, green: g, blue: b} = get_midnightblue_color();
   println!("Midnight Blue = rgb({}, {}, {})", r, g, b); //Midnight Blue = rgb(25, 25, 112)
 }
@@ -72,31 +72,31 @@ fn get_midnightblue_color() -> Color {
 
 ## Tuple structs
 
-⭐️ When a tuple struct  has only one element, we call it **new type pattern**. Because it helps to create a new type.
+⭐️ When a tuple struct has only one element, we call it **newtype pattern**. Because it helps to create a new type.
 
 ```rust
-struct Color (u8, u8, u8);
+struct Color(u8, u8, u8);
 struct Kilometers(i32);
 
 fn main() {
-  // creating an instance
-  let black = Color (0, 0, 0);
+  // Creating an instance
+  let black = Color(0, 0, 0);
 
-  // destructure the instance using a `let` binding, this will not destruct black instance
-  let Color (r, g, b) = black;
+  // Destructure the instance using a `let` binding, this will not destruct black instance
+  let Color(r, g, b) = black;
   println!("Black = rgb({}, {}, {})", r, g, b); //black = rgb(0, 0, 0);
 
-  //newtype pattern
+  // Newtype pattern
   let distance = Kilometers(20);
-  // destructure the instance using a `let` binding
+  // Destructure the instance using a `let` binding
   let Kilometers(distance_in_km) = distance;
   println!("The distance: {} km", distance_in_km); //The distance: 20 km
 }
 ```
 
 ## Unit structs
 
-This is rarely useful on its own, but in combination with other features it can become useful.
+This is rarely useful on its own. But in combination with other features, it can become useful.
 
 > [📖](https://doc.rust-lang.org/book/first-edition/structs.html) ex: A library may ask you to create a structure that implements a certain trait to handle events. If you don’t have any data you need to store in the structure, you can create a unit-like struct.
 

source/docs/b3.enums.md

@@ -14,23 +14,23 @@ enum Day {
     Saturday
 }
 
-// Day is the enum
+// The `Day` is the enum
 // Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday are the variants
 ```
 
-⭐️ Variants can be accessed through :: notation , ex. Day::Sunday
+⭐️ Variants can be accessed through :: notation, ex. Day::Sunday
 
 ⭐️ Each enum **variant** can have,
-* no data (unit variant)
-* unnamed ordered data (tuple variant)
-* named data (struct variant)
+* No data (unit variant)
+* Unnamed ordered data (tuple variant)
+* Named data (struct variant)
 
 
 ```rust
 enum FlashMessage {
-  Success, //a unit variant
-  Warning{ category: i32, message: String }, //a struct variant
-  Error(String) //a tuple variant
+  Success, // A unit variant
+  Warning{ category: i32, message: String }, // A struct variant
+  Error(String) // A tuple variant
 }
 
 fn main() {
@@ -45,11 +45,11 @@ fn main() {
 }
 
 fn print_flash_message(m : FlashMessage) {
-  // pattern matching with enum
+  // Pattern matching with enum
   match m {
     FlashMessage::Success =>
       println!("Form Submitted correctly"),
-    FlashMessage::Warning {category, message} => //Destructure, should use same field names
+    FlashMessage::Warning {category, message} => // Destructure, should use same field names
       println!("Warning : {} - {}", category, message),
     FlashMessage::Error(msg) =>
       println!("Error : {}", msg)

source/docs/b4.generics.md

@@ -3,18 +3,18 @@ title: Generics
 
 > [📖](https://doc.rust-lang.org/beta/book/first-edition/generics.html) Sometimes, when writing a function or data type, we may want it to work for multiple types of arguments. In Rust, we can do this with generics.
 
-💭 The concept is, instead of declaring a specific data type we use an uppercase letter(or CamelCase identifier). ex, **instead x : u8** we use **x : T** . but we have to inform to the compiler that T is a generic type(can be any type) by adding `<T>` at first.
+💭 The concept is, instead of declaring a specific data type we use an uppercase letter(or CamelCase identifier). ex, **instead of x : u8** we use **x : T** . but we have to inform to the compiler that T is a generic type(can be any type) by adding `<T>` at first.
 
 ### Generalizing functions
 
 ```rust
 fn takes_anything<T>(x: T) { // x has type T, T is a generic type
 }
 
-fn takes_two_of_the_same_things<T>(x: T, y: T) { // both x and y has same type
+fn takes_two_of_the_same_things<T>(x: T, y: T) { // Both x and y has the same type
 }
 
-fn takes_two_things<T, U>(x: T, y: U) { // multiple types
+fn takes_two_things<T, U>(x: T, y: U) { // Multiple types
 }
 ```
 
@@ -31,8 +31,8 @@ fn main() {
   let point_b = Point { x: 0.0, y: 0.0 }; // T is a float type
 }
 
-// 🔎 When addding an implementation for a generic struct, the type parameters should be declared after the impl as well
-// impl<T> Point<T> {
+// 🔎 When adding an implementation for a generic struct, the type parameters should be declared after the impl as well
+//   impl<T> Point<T> {
 ```
 
 ### Generalizing enums
@@ -58,28 +58,28 @@ enum Result<T, E> {
 ```rust
 // 01 - - - - - - - - - - - - - - - - - - - - - -
 fn get_id_by_username(username: &str) -> Option<usize> {
-    //if username can be found in the system, set userId
+    // if username can be found in the system, set userId
         return Some(userId);
-    //else
+    // else
         None
 }
 
-//💭 So on above function, instead of setting return type as usize
-// set return type as Option<usize>
-//Instead of return userId, return Some(userId)
-// else None (💡remember? last return statement no need return keyword and ending ;)
+// 💭 So, on the above function, instead of setting return type as usize
+//   set return type as Option<usize>
+// Instead of return userId, return Some(userId)
+//   else None (💡remember? last return statement no need return keyword and ending ;)
 
 // 02 - - - - - - - - - - - - - - - - - - - - - -
 struct Task {
     title: String,
     assignee: Option<Person>,
 }
 
-//💭 Instead of assignee: Person, we use Option<Person>
-//Because the task has not been assigned to a specific person
+// 💭 Instead of assignee: Person, we use Option<Person>
+// because the task has not been assigned to a specific person
 
 // - - - - - - - - - - - - - - - - - - - - - - -
-//when using Option types as return types on functions
+// When using Option types as return types on functions
 // we can use pattern matching to catch the relevant return type(Some/None) when calling them
 
 fn main() {
@@ -98,20 +98,20 @@ fn main() {
 ```rust
 // - - - - - - - - - - - - - - - - - - - - - -
 fn get_word_count_from_file(file_name: &str) -> Result<u32, &str> {
-  //if the file is not found on the system, return error
+  // if the file is not found on the system, return error
     return Err("File can not be found!")
-  //else, count and return the word count
-    //let mut word_count: u32; ....
+  // else, count and return the word count
+    // let mut word_count: u32; ....
     Ok(word_count)
 }
 
-//💭 on above function,
-// instead panic(break) the app, when a file can not be found; return Err(something)
+// 💭 On the above function,
+// instead panic(break) the app, when the file can not be found; return Err(something)
 // or when it could get the relevant data; return Ok(data)
 
 
 // - - - - - - - - - - - - - - - - - - - - - - -
-// we can use pattern matching to catch the relevant return type(Ok/Err) when calling it
+// We can use pattern matching to catch the relevant return type(Ok/Err) when calling it
 
 fn main() {
     let mut file_name = "file_a";