Merge pull request #50 from kimtth/main

fix(docs): correct typos

Author: atulkhare4096

async-book/src/ch05-the-state-machine-reveal.md

@@ -148,7 +148,7 @@ async fn pipeline(url: &str) -> Result<usize, Error> {
 <details>
 <summary>🔑 Solution</summary>
 
-Four states:
+Five states:
 
 1. **Start** — stores `url`
 2. **WaitingFetch** — stores `url`, `fetch` future

c-cpp-book/src/ch03-built-in-types.md

@@ -12,7 +12,7 @@
 | Unicode           | char                           | 'a', '$'                      |
 | Boolean           | bool                           | true, false                   |
 
-- Rust permits arbitrarily use of ```_``` between numbers for ease of reading
+- Rust permits arbitrary use of ```_``` between numbers for ease of reading
 ----
 ### Rust type specification and assignment
 - Rust uses the ```let``` keyword to assign values to variables. The type of the variable can be optionally specified after a ```:```
@@ -24,7 +24,7 @@ fn main() {
     let z = 42u32;
 }
 ``` 
-- Function parameters and return values (if any) require an explicit type. The following takes an u8 parameter and returns u32
+- Function parameters and return values (if any) require an explicit type. The following takes a u8 parameter and returns u32
 ```rust
 fn foo(x : u8) -> u32
 {

c-cpp-book/src/ch05-data-structures.md

@@ -236,7 +236,7 @@ fn main() {
 
 # Rust tuple structs
 - Rust tuple structs are similar to tuples and individual fields don't have names
-    - Like tuples, individual elements are accessed using .0, .1, .2, .... A common use case for tuple structs is to wrap primitive types to create custom types. **This can useful to avoid mixing differing values of the same type**
+    - Like tuples, individual elements are accessed using .0, .1, .2, .... A common use case for tuple structs is to wrap primitive types to create custom types. **This can be useful to avoid mixing differing values of the same type**
 ```rust
 struct WeightInGrams(u32);
 struct WeightInMilligrams(u32);

c-cpp-book/src/ch08-crates-and-modules.md

@@ -5,7 +5,7 @@
 - Modules are the fundamental organizational unit of code within crates
     - Each source file (.rs) is its own module, and can create nested modules using the ```mod``` keyword.
     - All types in a (sub-) module are **private** by default, and aren't externally visible within the same crate unless they are explicitly marked as ```pub``` (public). The scope of ```pub``` can be further restricted to ```pub(crate)```, etc
-    - Even if an type is public, it doesn't automatically become visible within the scope of another module unless it's imported using the ```use``` keyword. Child submodules can reference types in the parent scope using the ```use super::```
+    - Even if a type is public, it doesn't automatically become visible within the scope of another module unless it's imported using the ```use``` keyword. Child submodules can reference types in the parent scope using the ```use super::```
     - Source files (.rs) aren't automatically included in the crate **unless** they are explicitly listed in ```main.rs``` (executable) or ```lib.rs```
 
 # Exercise: Modules and functions
@@ -154,7 +154,7 @@ fn main() {
 # Using community crates from crates.io
 - Rust has a vibrant ecosystem of community crates (see https://crates.io/)
     - The Rust philosophy is to keep the standard library compact and outsource functionality to community crates
-    - There is no hard and fast rule about using community crates, but the rule of thumb should be ensure that the crate has a decent maturity level (indicated by the version number), and that it's being actively maintained. Reach out to internal sources if in doubt about a crate
+    - There is no hard and fast rule about using community crates, but the rule of thumb should be to ensure that the crate has a decent maturity level (indicated by the version number), and that it's being actively maintained. Reach out to internal sources if in doubt about a crate
 - Every crate published on ```crates.io``` has a major and minor version
     - Crates are expected to observe the major and minor ```SemVer``` guidelines defined here: https://doc.rust-lang.org/cargo/reference/semver.html
     - The TL;DR version is that there should be no breaking changes for the same minor version. For example, v0.11 must be compatible with v0.15 (but v0.20 may have breaking changes)

c-cpp-book/src/ch09-1-error-handling-best-practices.md

@@ -98,7 +98,7 @@ Let's break down what's happening here. `ConfigError` has just **two variants**
 | `FileRead(io::Error)` | The original I/O error | `#[from]` auto-converts via `?` |
 | `Invalid { message }` | A human-readable explanation | Your validation code |
 
-Now you can Write functions that return `Result<T, ConfigError>`:
+Now you can write functions that return `Result<T, ConfigError>`:
 
 ```rust
 fn read_config(path: &str) -> Result<String, ConfigError> {

c-cpp-book/src/ch09-error-handling.md

@@ -31,7 +31,7 @@ enum Result<T, E> {
 # Rust Option type
 - The Rust ```Option``` type is an ```enum``` with only two variants: ```Some<T>``` and ```None```
     - The idea is that this represents a ```nullable``` type, i.e., it either contains a valid value of that type (```Some<T>```), or has no valid value (```None```)
-    - The ```Option``` type is used in APIs result of an operation either succeeds and returns a valid value or it fails (but the specific error is irrelevant). For example, consider parsing a string for an integer value
+    - The ```Option``` type is used in APIs where the result of an operation either succeeds and returns a valid value or it fails (but the specific error is irrelevant). For example, consider parsing a string for an integer value
 ```rust
 fn main() {
     // Returns Option<usize>

c-cpp-book/src/ch11-from-and-into-traits.md

@@ -3,7 +3,7 @@
 > **What you'll learn:** Rust's type conversion traits — `From<T>` and `Into<T>` for infallible conversions, `TryFrom` and `TryInto` for fallible ones. Implement `From` and get `Into` for free. Replaces C++ conversion operators and constructors.
 
 - ```From``` and ```Into``` are complementary traits to facilitate type conversion
-- Types normally implement on the ```From``` trait. the ```String::from()``` converts from "&str" to ```String```, and compiler can automatically derive ```&str.into```
+- Types normally implement the ```From``` trait. The ```String::from()``` converts from "&str" to ```String```, and the compiler can automatically derive ```&str.into```
 ```rust
 struct Point {x: u32, y: u32}
 // Construct a Point from a tuple

c-cpp-book/src/ch12-1-iterator-power-tools.md

@@ -218,7 +218,7 @@ fn main() {
 
 
 # Rust iterators
-- The ```Iterator``` trait is used to implement iteration over user defined types (https://doc.rust-lang.org/std/iter/trait.IntoIterator.html)
+- The ```Iterator``` trait is used to implement iteration over user-defined types (https://doc.rust-lang.org/std/iter/trait.IntoIterator.html)
     - In the example, we'll implement an iterator for the Fibonacci sequence, which starts with 1, 1, 2, ... and the successor is the sum of the previous two numbers
     - The ```associated type``` in the ```Iterator``` (```type Item = u32;```) defines the output type from our iterator (```u32```)
     - The ```next()``` method simply contains the logic for implementing our iterator. In this case, all state information is available in the ```Fibonacci``` structure

c-cpp-book/src/ch12-closures.md

@@ -64,7 +64,7 @@ fn main() {
 </details>
 
 # Rust iterators
-- Iterators are one of the most powerful features of Rust. They enable very elegant methods for perform operations on collections, including filtering (```filter()```), transformation (```map()```), filter and map (```filter_and_map()```), searching (```find()```) and much more
+- Iterators are one of the most powerful features of Rust. They enable very elegant methods for performing operations on collections, including filtering (```filter()```), transformation (```map()```), filter and map (```filter_and_map()```), searching (```find()```) and much more
 - In the example below, the ```|&x| *x >= 42``` is a closure that performs the same comparison. The ```|x| println!("{x}")``` is another closure
 ```rust
 fn main() {
@@ -355,7 +355,7 @@ fn main() {
 ----
 
 # Rust iterators
-- The ```Iterator``` trait is used to implement iteration over user defined types (https://doc.rust-lang.org/std/iter/trait.IntoIterator.html)
+- The ```Iterator``` trait is used to implement iteration over user-defined types (https://doc.rust-lang.org/std/iter/trait.IntoIterator.html)
     - In the example, we'll implement an iterator for the Fibonacci sequence, which starts with 1, 1, 2, ... and the successor is the sum of the previous two numbers
     - The ```associated type``` in the ```Iterator``` (```type Item = u32;```) defines the output type from our iterator (```u32```)
     - The ```next()``` method simply contains the logic for implementing our iterator. In this case, all state information is available in the ```Fibonacci``` structure

engineering-book/src/ch06-dependency-management-and-supply-chain-s.md

@@ -267,7 +267,7 @@ Each duplicate adds compile time and binary size.
 
 ### Application: Multi-Crate Dependency Hygiene
 
-The the workspace uses `[workspace.dependencies]` for centralized
+The workspace uses `[workspace.dependencies]` for centralized
 version management — an excellent practice. Combined with
 [`cargo tree --duplicates`](ch07-release-profiles-and-binary-size.md) for size
 analysis, this prevents version drift and reduces binary bloat: