Suggesting to add Default to important traits. (#243)

* Suggesting to add `Default` to important traits.

This is a great trait to know about, it is used very often.

* Change `Implemented` to tuple struct.

It saves vertical space.

src/SUMMARY.md

@@ -134,6 +134,7 @@
     - [Read and Write](traits/read-write.md)
     - [Add, Mul, ...](traits/operators.md)
     - [Drop](traits/drop.md)
+    - [Default](traits/default.md)
 - [Generics](generics.md)
   - [Generic Data Types](generics/data-types.md)
   - [Generic Methods](generics/methods.md)

src/traits/default.md

@@ -0,0 +1,47 @@
+# The `Default` Trait
+
+`Default` trait provides a default implementation of a trait.
+
+```rust,editable
+#[derive(Debug, Default)]
+struct Derived {
+    x: u32,
+    y: String,
+    z: Implemented,
+}
+
+#[derive(Debug)]
+struct Implemented(String);
+
+impl Default for Implemented {
+    fn default() -> Self {
+        Self("John Smith".into())
+    }
+}
+
+fn main() {
+    let default_struct: Derived = Default::default();
+    println!("{default_struct:#?}");
+
+    let almost_default_struct = Derived {
+        y: "Y is set!".into(),
+        ..Default::default()
+    };
+    println!("{almost_default_struct:#?}");
+
+    let nothing: Option<Derived> = None;
+    println!("{:#?}", nothing.unwrap_or_default());
+}
+
+```
+
+<details>
+
+  * It can be implemented directly or it can be derived via `#[derive(Default)]`.
+  * Derived implementation will produce an instance where all fields are set to their default values.
+    * This means all types in the struct must implement `Default` too.
+  * Standard Rust types often implement `Default` with reasonable values (e.g. `0`, `""`, etc).
+  * The partial struct copy works nicely with default.
+  * Rust standard library is aware that types can implement `Default` and provides convenience methods that use it.
+
+</details>

src/traits/important-traits.md

@@ -7,3 +7,4 @@ We will now look at some of the most common traits of the Rust standard library:
 * `Read` and `Write` used for IO,
 * `Add`, `Mul`, ... used for operator overloading, and
 * `Drop` used for defining destructors.
+* `Default` used to construct a default instance of a type.