Error Handling

Author: dumindu

content/en/docs/e1-error-lifetimes.jpg

@@ -3,109 +3,106 @@ title: Smart Compiler
 slug: smart-compiler
 ---
 
-> [!caution]
-> This needs a refresh!
+## Compile-time Errors
 
-## Why Compiler?
+Rust focuses on strict code hygiene, and the compiler generates a highly specific set of warnings and errors to make it easier to identify and solve them.
 
-The Rust compiler does the most significant job to prevent errors in Rust programs. It **analyzes the code at compile-time** and issues warnings, if the code does not follow memory management rules or lifetime annotations correctly. 
+### Typos
 
-For example,
 ```rust
-#[allow(unused_variables)] //💡 A lint attribute used to suppress the warning; unused variable: `b`
+struct Person {
+    name: String,
+    company_name: String,
+}
+
+fn main() {
+    let steve = Person {
+        name: "Steve Jobs".to_string(),
+        company_name: "Apple".to_string(),
+    };
+
+    // Destructuring fields' values to a and b
+    let Person {fname: a, company_name: b} = steve;
+
+    println!("{a} {b}");
+}
+```
+
+> [!caution] Compile-time Error
+> ![Compile-time Error: Typos](/docs/e1-error-typos.jpg)
+
+### Ownership
+
+```rust
+#![allow(unused)] //💡 A lint attribute used to suppress the warning; unused variable: `b`
 fn main() {
     let a = vec![1, 2, 3];
     let b = a;
 
     println!("{:?}", a);
 }
+```
 
+> [!caution] Compile-time Error
+> ![Compile-time Error: Ownership](/docs/e1-error-ownership.jpg)
 
-// ------ Compile-time error ------
-error[E0382]: use of moved value: `a`
- --> src/main.rs:6:22
-  |
-3 |     let b = a;
-  |         - value moved here
-4 |
-5 |     println!("{:?}", a);
-  |                      ^ value used here after move
-  |
-  = note: move occurs because `a` has type `std::vec::Vec<i32>`, which does not implement the `Copy` trait
+### Lifetimes
 
-error: aborting due to previous error
-For more information about this error, try `rustc --explain E0382`.
+```rust
+fn main() {
+    let steve = Person{fname: "Steve", lname: "Jobs"};
+    steve.intro();
+}
+
+struct Person {
+    fname: &str,
+    lname: &str,
+}
 
-// ⭐ instead using #[allow(unused_variables)], consider using "let _b = a;" in line 4. 
-// Also you can use "let _ =" to completely ignore return values
+impl Person {
+    fn intro(&self) {
+        println!("Hello! I am {} {}.", self.fname, self.lname)
+    }
+}
 ```
 
-> [!recap]
-> In the previous sections, we have discussed memory management concepts like [ownership](/docs/ownership), [borrowing](/docs/borrowing), [lifetimes](/docs/lifetimes) and etc.
+> [!caution] Compile-time Error
+> ![Compile-time Error: Lifetimes](/docs/e1-error-lifetimes.jpg)
 
-Rust compiler checks not only issues related with lifetimes or memory management and also common coding mistakes, like the following code.
+### Concurrency
 
 ```rust
-struct Color {
-    r: u8,
-    g: u8,
-    b: u8,
-}
+use std::{rc::Rc, thread};
 
 fn main() {
-    let yellow = Color {
-        r: 255,
-        g: 255,
-        d: 0,
-    };
-
-    println!("Yellow = rgb({},{},{})", yellow.r, yellow.g, yellow.b);
-}
+    let data = Rc::new(vec![1, 2, 3]);
 
+    let value1 = Rc::clone(&data);
+    let handle1 = thread::spawn(move || {
+        println!("{:?}", &value1);
+    });
 
-// ------------ Compile-time error ------------
-error[E0560]: struct `Color` has no field named `d`
-  --> src/main.rs:11:9
-   |
-11 |         d: 0,
-   |         ^ field does not exist - did you mean `b`?
+    let value2 = Rc::clone(&data);
+    let handle2 = thread::spawn(move || {
+        println!("{:?}", &value2);
+    });
 
-error: aborting due to previous error
-For more information about this error, try `rustc --explain E0560`.
+    handle1.join().unwrap();
+    handle2.join().unwrap();
+}
 ```
 
-## Explain Error Codes
+> [!caution] Compile-time Error
+> ![Compile-time Error: Concurrency](/docs/e1-error-concurrency.jpg)
 
-Above error messages are very descriptive and we can easily see where is the error. But while we can not identify the issue via the error message, **`rustc --explain`** commands help us **to identify the error type and how to solve** it, by showing **simple code samples** which express the same problem and the solution we have to use. 
+## Error Codes
 
-For example, `rustc --explain E0571` shows the following output in the console.
+- Rust's error codes consist of the letter **E** followed by four digits.
+- Each code corresponds to a specific kind of error, and `rustc --explain <CODE>` provides more details to help to identify the error. 
+- The same explanations are also available in the [Rust Error Codes Index](https://doc.rust-lang.org/error_codes/error-index.html).
 
-```rust
-A `break` statement with an argument appeared in a non-`loop` loop.
+For example, `rustc --explain E0571` shows the following output in the console, and the same content is also available at https://doc.rust-lang.org/error_codes/E0571.html.
 
-Example of erroneous code:
-｀｀｀
-let result = while true {
-    if satisfied(i) {
-        break 2*i; // error: `break` with value from a `while` loop
-    }
-    i += 1;
-};
-｀｀｀
-
-The `break` statement can take an argument (which will be the value of the loop
-expression if the `break` statement is executed) in `loop` loops, but not
-`for`, `while`, or `while let` loops.
-
-Make sure `break value;` statements only occur in `loop` loops:
-｀｀｀
-let result = loop { // ok!
-    if satisfied(i) {
-        break 2*i;
-    }
-    i += 1;
-};
-｀｀｀
-```
+> [!search]
+> ![Explain Error Codes](/docs/e1-explain-error-codes.jpg)
 
-💡 Also you can read the same explanations via [Rust Compiler Error Index](https://doc.rust-lang.org/error_codes/error-index.html). For example to check the explanation of `E0571` error, you can use https://doc.rust-lang.org/error-index.html#E0571.