Merge remote-tracking branch 'origin/main' into github-pages

Author: dumindu

content/en/docs/b2.structs.md

@@ -4,7 +4,7 @@ slug: structs
 ---
 
 - Used to **encapsulate related properties into one unified data type**.
-- By convention, the name should follow **[PascalCase](https://en.wikipedia.org/wiki/Camel_case)**.
+- By convention, the name should follow [`PascalCase`](https://en.wikipedia.org/wiki/Camel_case).
 - 3 variants,
   - C-like structs: One or more `,` separated `name: value pairs` enclosed in `{}`
 
@@ -22,15 +22,19 @@ slug: structs
     struct Color(u8, u8, u8);
     ```
 
-  - Unit structs: A struct with no members
+  - Unit structs: A struct with no fields/ members
 
     ```rust
     struct Black;
     ```
 
-⭐️ 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**.
-
-> 💯 More complex examples can be found on [impls & traits](/docs/impls-and-traits), [lifetimes](/docs/lifetimes) and [modules](/docs/modules) sections.
+> ⭐️ 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**.
+>
+> 💡 In Rust, the term "instantiation" is used to describe the act of creating a concrete instance of a type (struct or enum).
+>
+> 💡 In Rust, the term "field" is used to describe a named component in a C-like struct & struct-like enum variant, and the term "element" is used to describe an unnamed component in a tuple struct & tuple-like enum variant. The term "member" is used to describe both.
+>
+> 💯 More complex examples can be found on [Impls and Traits](/docs/impls-and-traits), [Lifetimes](/docs/lifetimes) and [Modules](/docs/modules) sections.
 
 ## C-like Structs
 
@@ -47,7 +51,7 @@ struct Color {
 }
 ```
 
-### Initialization & Accessing Fields
+### Instantiation & Accessing Fields
 
 ```rust
 struct Color {
@@ -57,21 +61,21 @@ struct Color {
 }
 
 fn main() {
-    // 1. Initialization
+    // 1. Instantiation
     let white = Color {
         red: 255,
         green: 255,
         blue: 255,
     };
 
-    // 2. Initialization without redundant field names, when using the same variable names
+    // 2. Instantiation without redundant field names, when using the same variable names
     let (red, green, blue) = (0, 0, 0);
     let black = Color { red, green, blue };
 
-    // 3. Initialization + copy elements from another instance
+    // 3. Instantiation + copy fields' values from another instance
     let red = Color { red: 255, .. black }; // 💡 Copy green and blue from black
     let green = Color { green: 255, .. black }; // 💡 Copy red and blue from black
-    let mut blue = Color { .. black }; // 💡 Copy all elements from black
+    let mut blue = Color { .. black }; // 💡 Copy all fields' values from black
     blue.blue = 255;
 
      println!("RGB({}, {}, {})", white.red, white.green, white.blue); // RGB(255, 255, 255)
@@ -84,23 +88,24 @@ fn main() {
 ```
 
 ```rust
-// 4. Initialization with default values
+// 4. Instantiation with default values
+
 #[derive(Default)]
 struct Person {
     name: String,
     age: f32,
 }
 
 fn main() {
-    let a = Person::default(); // Initialization with default values
+    let a = Person::default(); // Instantiation with default values
 
     assert_eq!(a.name, ""); // String default value ""
     assert_eq!(a.age, 0.0); // f32 default value 0.0
 }
-
-// 💡 #[derive(Default)] attribute automatically generates a default implementation for the Default trait for a struct or enum.
 ```
 
+💡 In Rust, the `#[derive()]` attribute is used to automatically generate an implementation of certain traits for a custom data structure (struct and enum), instead of you writing them by hand. The [`std::default::Default`](https://doc.rust-lang.org/std/default/trait.Default.html) trait allows us to create a new instance of a type with the `Type::default()` method.
+
 💯 5. We can also use a constructor function inside an `impl` block to initialize a struct.
 
 ### Destructuring
@@ -124,42 +129,14 @@ fn main() {
         company_name: "Apple".to_string(),
     };
 
-    let Person {name: a, company_name: b} = steve; // 1. Destructuring elements to a and b
+    let Person {name: a, company_name: b} = steve; // 1. Destructuring fields' values to a and b
     println!("{a} {b}"); // Steve Jobs Apple
 
-    let Person {company_name: c, .. } = get_steve(); // 2. Destructuring only selected elements + a struct returned from a function
+    let Person {company_name: c, .. } = get_steve(); // 2. Destructuring only selected fields' values; directly from the function call
     println!("{c}"); // Apple
 }
 
-// 💯 let Person {name: ref a, company_name: ref b} = steve; // add ref keyword, to pass an element as a reference
-```
-
-### Debug Printing and Pretty Debug Printing
-
-> 💡 `#[derive(Debug)]` attribute is used to automatically generate an implementation of the `Debug trait` for a custom data structure, such as a `struct` or an `enum`.
-
-```rust
-#![allow(unused)] // 💡 skip unused warnings in crate/ module level
-
-#[derive(Debug)]
-struct Person {
-    name: String,
-    company_name: String,
-}
-
-fn main() {
-    let (name, company_name) = ("Steve Jobs".to_string(), "Apple".to_string());
-    let a = Person { name, company_name };
-
-    println!("{a:?}"); // 💡 Debug printing with :? format specifier
-    // Person { name: "Steve Jobs", company_name: "Apple" }
-
-    println!("{a:#?}"); // 💡 Pretty-debug printing with :#? format specifier
-    // Person {
-    //     name: "Steve Jobs",
-    //     company_name: "Apple",
-    // }
-}
+// 💯 let Person {name: ref a, company_name: ref b} = steve; // add ref keyword, to pass a field's value as a reference
 ```
 
 ## Tuple Structs
@@ -176,7 +153,7 @@ struct Color(u8, u8, u8);
 struct Department(String);
 ```
 
-### Initialization & Accessing Elements
+### Instantiation & Accessing Elements
 
 ```rust
 struct Color(u8, u8, u8);
@@ -206,43 +183,20 @@ fn get_department() -> Department {
 fn main() {
     let white = Color(255, 255, 255);
 
-    let Color(red, green, blue) = white; // 💡 let Color(red, blue, .. ) = white; // Destructuring only selected elements
+    let Color(red, green, blue) = white; // 💡 let Color(red, blue, .. ) = white; // Destructuring only selected field's value
     println!("RGB({}, {}, {})", red, green, blue); // RGB(255, 255, 255)
 
     let Department(name) = get_department();
     println!("{}", name); // Engineering
 }
 ```
 
-### Debug Printing and Pretty Debug Printing
-
-```rust
-#![allow(unused)]
-
-#[derive(Debug)]
-struct Department(String);
-
-fn main() {
-    let a = Department("Engineering".to_string());
-
-    println!("{a:?}");
-    // Department("Engineering")
-
-    println!("{a:#?}");
-    // Department(
-    //     "Engineering",
-    // )
-}
-```
-
 ## Unit Structs
 
-- It defines a new type, but it resembles an empty tuple, \(\)
+- It defines a new type, but it resembles an empty tuple, `()`
 - This is rarely useful on its own. But in combination with other features (such as generics), 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.
-
-### Definition & Initialization
+### Definition & Instantiation
 
 ```rust
 struct Electron;
@@ -252,15 +206,44 @@ fn main() {
 }
 ```
 
-### Debug Printing and Pretty Debug Printing
+> [📖](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.
+
+## Debug Printing and Pretty Debug Printing
+
+In Rust, the `#[derive()]` attribute is used to automatically generate an implementation of certain traits for a custom data structure (struct and enum), instead of you writing them by hand. The [`std::fmt::Debug`](https://doc.rust-lang.org/std/fmt/trait.Debug.html) trait allows us to format a value with `{:?}` or `{:#?}` in `println!` and similar macros.
 
 ```rust
+#![allow(unused)] // 💡 skip unused warnings, as we don't read fields in the structs
+
 #[derive(Debug)]
 struct Electron;
 
+#[derive(Debug)]
+struct Department(String);
+
+#[derive(Debug)]
+struct Person {
+    name: String,
+    company_name: String,
+}
+
 fn main() {
     let a = Electron;
-    println!("{a:?}"); // Electron
-    println!("{a:#?}"); // Electron
+    println!("{a:?}"); // Electron // 💡{a:#?} prints the same
+
+    let b = Department("Engineering".to_string());
+    println!("{b:?}"); // Department("Engineering")
+    println!("{b:#?}");
+    // Department(
+    //     "Engineering",
+    // )
+    
+    let c = Person { name: "Steve Jobs".to_string(), company_name: "Apple".to_string() };
+    println!("{c:?}"); // Person { name: "Steve Jobs", company_name: "Apple" }
+    println!("{c:#?}");
+    // Person {
+    //     name: "Steve Jobs",
+    //     company_name: "Apple",
+    // }
 }
 ```