🦀 Update to current Edition

Author: dumindu

content/en/docs/a1.why-rust.md

@@ -11,14 +11,18 @@ Since Rust 1.0, major updates have been released as [`Editions`](/docs/cargo-cra
 
 ## Initial Goals
 
-The goal of Rust is to be a good programming language for creating highly concurrent, safe and performant systems.
+> Rust is a systems programming language focused on three goals: safety, speed, and concurrency.
+> </br>~ Rust Documentation
 
-> **"Rust is a systems programming language focused on three goals: safety, speed, and concurrency."
-> </br>~ Rust Documentation**
+**Rust is a modern, [multi-platform](https://doc.rust-lang.org/rustc/platform-support.html), [multi-paradigm](https://en.wikipedia.org/wiki/Comparison_of_multi-paradigm_programming_languages), [statically compiled](https://en.wikipedia.org/wiki/Compiled_language), memory & thread safety–focused, systems programming language.**
 
-Rust is a very young and very modern language. It's a **[compiled programming language](https://en.wikipedia.org/wiki/Compiled_language)** and it uses [LLVM](https://en.wikipedia.org/wiki/LLVM) on the backend. Also, Rust is a **[multi-paradigm programming language](https://en.wikipedia.org/wiki/Comparison_of_multi-paradigm_programming_languages)**, which supports imperative procedural, concurrent actor, object-oriented and pure functional styles. It also supports generic programming and metaprogramming, in both static and dynamic styles.
+- It uses [LLVM](https://en.wikipedia.org/wiki/LLVM) on the backend and supports many different operating systems, architectures, and targets.
+- It supports imperative procedural, concurrent actor, object-oriented, and pure functional styles. Rust also supports generic programming and metaprogramming, in both static and dynamic styles.
+- It doesn't use a built-in runtime or an automated garbage collection system \(GC\).
 
-> One of Rust’s most unique and compelling features is [Ownership](/docs/ownership), which is used to achieve memory safety. Rust creates memory pointers optimistically, checks memory pointers’ limited accesses at compile-time with the usage of [References and Borrowing](/docs/borrowing). And it does automatic compile-time memory management by checking the [Lifetimes](/docs/lifetimes).
+    > 💡 However, async Rust requires an async runtime, which is provided by community-maintained crates like [`tokio`](https://github.com/tokio-rs/tokio), [`soml`](https://github.com/smol-rs/smol) etc. The async runtime will be bundled into the final executable.
+
+- One of Rust’s most unique and compelling features is [Ownership](/docs/ownership), which is used to achieve memory safety. Rust creates memory pointers optimistically, checks memory pointers’ limited accesses at compile-time with the usage of [References and Borrowing](/docs/borrowing). And it does automatic compile-time memory management by checking the [Lifetimes](/docs/lifetimes).
 
 ## Influences
 
@@ -38,11 +42,7 @@ Its design elements came from a wide range of sources.
 
 and etc.
 
-Rust **doesn't use a built-in runtime** or an automated garbage collection system \(GC\).
-
-> 💡 However, async Rust requires an async runtime, which is provided by community-maintained crates like [`tokio`](https://github.com/tokio-rs/tokio), [`async-std`](https://github.com/async-rs/async-std), [`soml`](https://github.com/smol-rs/smol) etc. The async runtime will be bundled into the final executable.
-
-Rust compiler **observes the code at compile-time** and helps to [prevent many types of errors](https://doc.rust-lang.org/error-index.html) that are possible to write in C, C++ like programming languages.
+Rust compiler observes the code at compile-time and helps to [prevent many types of errors](https://doc.rust-lang.org/error-index.html) that are possible to write in C, C++ like programming languages.
 
 ## 👨‍🏫 Before going to the next...
 

content/en/docs/a10.control-flows.md

@@ -81,22 +81,29 @@ println!("Current team size : {}", team_size); // Current team size : Medium
 
 ⭐️ **Return data type should be the same on each block when using this as an expression.**
 
-
 ## match
 
+- With multiple patterns
+
 ```rust
 let tshirt_width = 20;
 let tshirt_size = match tshirt_width {
-    16 => "S", // check 16
-    17 | 18 => "M", // check 17 and 18
-    19 ..= 21 => "L", // check from 19 to 21 (19,20,21)
-    22 => "XL",
-    _ => "Not Available",
+    13 => "XS",     // check 13
+    14 | 15 => "S", // check 14 and 15
+    16..18 => "M",  // check from 16 to 17 / 18 exclusive (16,17)
+    18..=20 => "L", // check from 18 to 20 (18,19,20)
+
+    x if x > 20 && x < 26 => "XL", // check 21 to 25 (21,22,23,24,25)
+    // >,>=,<,<= via assigning the value to a variable (x) + if
+
+    _ => "Not Available", // default behavior, if none of conditions matches
 };
 
 println!("{}", tshirt_size); // L
 ```
 
+- Without default behavior
+
 ```rust
 let is_allowed = false;
 let list_type = match is_allowed {
@@ -109,6 +116,8 @@ let list_type = match is_allowed {
 println!("{}", list_type); // Restricted
 ```
 
+- With multiple variable matchings
+
 ```rust
 let marks_paper_a: u8 = 25;
 let marks_paper_b: u8 = 30;
@@ -124,162 +133,217 @@ let output = match (marks_paper_a, marks_paper_b) {
 println!("{}", output); // Work hard
 ```
 
-
 ## loop
 
+- Infinite `loop`
+
 ```rust
+// ⚠️ This will run forever without terminating. Termininate manually (Ctrl+C)
 loop {
-	println!("Loop forever!");
+    println!("Loop forever!");
 }
 ```
 
+- With `break` and `continue`
+
 ```rust
-// Usage of break and continue
 let mut a = 0;
 
 loop {
-	if a == 0 {
-		println!("Skip Value : {}", a);
-		a += 1;
-		continue;
-	} else if a == 2 {
-		println!("Break At : {}", a);
-		break;
-	}
-
-	println!("Current Value : {}", a);
-	a += 1;
+    if a == 0 {
+        println!("Skip Value : {}", a);
+        a += 1;
+        continue;
+    } else if a == 2 {
+        println!("Break At : {}", a);
+        break;
+    }
+
+    println!("Current Value : {}", a);
+    a += 1;
 }
 ```
 
+- Returning a value with `break`
+
+```rust
+let (mut x, y) = (1, 10);
+
+let z = loop {
+    x *= 2; // x = 2,4,8,16...
+
+    if x >= y { // 16 >= 10, so return 16
+        break x;
+    }
+};
+
+println!("{z}"); // 16
+```
+
+- Labeling and `break` the outer `loop`
+
 ```rust
-// Outer break
 let mut b1 = 1;
 
-'outer_loop: loop { //set label outer_loop
-  let mut b2 = 1;
+'outer: loop { // set label outer (or any other snake_case name)
+    let mut b2 = 1;
 
-  'inner_loop: loop {
-    println!("Current Value : [{}][{}]", b1, b2);
+    'inner: loop { // set label inner
+        println!("Current Value : [{}][{}]", b1, b2);
 
-    if b1 == 2 && b2 == 2 {
-        break 'outer_loop; // kill outer_loop
-    } else if b2 == 5 {
-    	break;
-    }
+        if b1 == 2 && b2 == 2 {
+            break 'outer; // kill outer loop
+        } else if b2 == 5 {
+            break;
+        }
 
-    b2 += 1;
-  }
+        b2 += 1;
+    }
 
-  b1 += 1;
+    b1 += 1;
 }
 ```
 
-
 ## while
 
+- Infinite `while`
+
+```rust
+// ⚠️ This will run forever without terminating. Termininate manually (Ctrl+C)
+while true {
+    println!("While forever!");
+}
+```
+
+- A simple `while`
+
 ```rust
 let mut a = 1;
 
 while a <= 10 {
-	println!("Current value : {}", a);
-	a += 1; //no ++ or -- on Rust
+    println!("Current value : {}", a);
+    a += 1; //no ++ or -- on Rust
 }
 ```
 
+- With `break` and `continue`
+
 ```rust
-// Usage of break and continue
 let mut b = 0;
 
 while b < 5 {
-	if b == 0 {
-		println!("Skip value : {}", b);
-		b += 1;
-		continue;
-	} else if b == 2 {
-		println!("Break At : {}", b);
-		break;
-	}
-
-	println!("Current value : {}", b);
-	b += 1;
+    if b == 0 {
+        println!("Skip value : {}", b);
+        b += 1;
+        continue;
+    } else if b == 2 {
+        println!("Break At : {}", b);
+        break;
+    }
+
+    println!("Current value : {}", b);
+    b += 1;
 }
+
+// 💡 You can't break with a value in a while
 ```
 
+- Labeling and `break` the outer `while`
+
 ```rust
-// Outer break
 let mut c1 = 1;
 
-'outer_while: while c1 < 6 { //set label outer_while
-	let mut c2 = 1;
+'outer: while c1 < 6 { // set label outer (or any other snake_case name)
+    let mut c2 = 1;
+
+    'inner: while c2 < 6 { // set label inner
+        println!("Current Value : [{}][{}]", c1, c2);
 
-	'inner_while: while c2 < 6 {
-		println!("Current Value : [{}][{}]", c1, c2);
-		if c1 == 2 && c2 == 2 { break 'outer_while; } //kill outer_while
-		c2 += 1;
-	}
+        if c1 == 2 && c2 == 2 {
+            break 'outer; // kill outer while
+        }
 
-	c1 += 1;
+        c2 += 1;
+    }
+
+    c1 += 1;
 }
 ```
 
-
 ## for
 
+- A simple `for`
+
 ```rust
 // 0 to 10 (10 exclusive); In other languages, `for(i = 0; i < 10; i++)`
 for i in 0..10 {
-  println!("Current value : {}", i);
+    println!("Current value : {}", i);
 }
 ```
 
 ```rust
 // 1 to 10 (10 inclusive); In other languages, `for(i = 1; i <= 10; i++)`
 for i in 1..=10 {
-  println!("Current value : {}", i);
+    println!("Current value : {}", i);
 }
 ```
 
+- With `break` and `continue`
+
 ```rust
-// Usage of break and continue
+// 💡 You can't break with a value in a for
 for b in 0..6 {
-  if b == 0 {
-    println!("Skip Value : {}", b);
-    continue;
-  } else if b == 2 {
-    println!("Break At : {}", b);
-    break;
-  }
-
-  println!("Current value : {}", b);
+    if b == 0 {
+        println!("Skip Value : {}", b);
+        continue;
+    } else if b == 2 {
+        println!("Break At : {}", b);
+        break;
+    }
+
+    println!("Current value : {}", b);
 }
 ```
 
+- Labeling and `break` the outer `for`
+
 ```rust
-// Outer break
-'outer_for: for c1 in 1..6 { //set label outer_for
+'outer: for c1 in 1..6 { // set label outer (or any other snake_case name)
 
-  'inner_for: for c2 in 1..6 {
-    println!("Current Value : [{}][{}]", c1, c2);
-    if c1 == 2 && c2 == 2 { break 'outer_for; } //kill outer_for
-  }
+    'inner: for c2 in 1..6 { // set label inner
+        println!("Current Value : [{}][{}]", c1, c2);
 
+        if c1 == 2 && c2 == 2 {
+            break 'outer; // kill outer for
+        }
+    }
 }
 ```
 
+- Working with arrays and vectors
+
 ```rust
-// Working with arrays/vectors
 let group : [&str; 4] = ["Mark", "Larry", "Bill", "Steve"];
 
 for n in 0..group.len() { // group.len() = 4 -> 0..4 👎 check group.len() on each iteration
-  println!("Current Person : {}", group[n]);
+    println!("Current Person : {}", group[n]);
 }
 
 for person in group.iter() { // 👍 group.iter() turn the array into a simple iterator
-  println!("Current Person : {}", person);
+    println!("Current Person : {person}");
 }
 
 for (index, person) in group.iter().enumerate() { // 💡 group.iter().enumerate() helps to read both the current index (starting from zero) and the value
-  println!("Person {} : {}", index, person);
+    println!("Person {index} : {person}");
+}
+```
+
+- Working with vector of tuples
+
+```rust
+let list = vec![(1, "Mark"), (2, "Larry"), (3, "Steve")];
+
+for (index, person) in list {
+    println!("Person {index} : {person}");
 }
 ```