The Rust Book (Abridged)

https://jasonwalton.ca/rust-book-abridged
Admin
This project is a condensed version of "The Rust Programming Language" book, rewritten to focus on...
Tokens:65,459
Snippets:844
Trust Score:4.9
Update:2 months ago
Show doc for...
Tokens:
Raw
### Install Clippy

Source: https://jasonwalton.ca/rust-book-abridged/zz-appendix/appendix-04-useful-development-tools

Use rustup to add the clippy component to your toolchain.

```bash
$ rustup component add clippy  
```

--------------------------------

### Install and run a custom Cargo command

Source: https://jasonwalton.ca/rust-book-abridged/ch14-more-about-cargo

Installs a custom Cargo tool and demonstrates executing it as a Cargo subcommand.

```bash
$ cargo install cargo-audit  
$ cargo audit  
```

--------------------------------

### Install Rust on Linux or MacOS

Source: https://jasonwalton.ca/rust-book-abridged/ch01-getting-started

Use the rustup script to install the Rust toolchain and ensure build tools are present.

```bash
curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | sh  
xcode-select --install  
```

--------------------------------

### Install a binary crate

Source: https://jasonwalton.ca/rust-book-abridged/ch14-more-about-cargo

Installs a binary crate from crates.io, placing the executable in the default Cargo bin directory.

```bash
$ cargo install ripgrep  
```

--------------------------------

### Install rustfmt

Source: https://jasonwalton.ca/rust-book-abridged/zz-appendix/appendix-04-useful-development-tools

Command to add the rustfmt component to your Rust installation.

```bash
$ rustup component add rustfmt  
```

--------------------------------

### Use workspace library in binary

Source: https://jasonwalton.ca/rust-book-abridged/ch14-more-about-cargo

Example of importing and using a library crate from the same workspace.

```rust
use add_one;  
  
fn main() {  
    let num = 10;  
    println!("Hello, world! {num} plus one is {}!", add_one::add_one(num));  
}  
```

--------------------------------

### HTTP GET Request Format

Source: https://jasonwalton.ca/rust-book-abridged/ch20/ch20-01-single-threaded-web-server

Example of a standard HTTP GET request structure.

```text
GET /index.html HTTP/1.1  
Host: example.com  
Accept-Language: en-us  
Accept-Encoding: gzip, deflate  
Connection: Keep-Alive  
  

```

--------------------------------

### Implement library function

Source: https://jasonwalton.ca/rust-book-abridged/ch14-more-about-cargo

Example implementation of a function in a library crate.

```rust
pub fn add_one(x: i32) -> i32 {  
    x + 1  
}  
```

--------------------------------

### Grep command usage

Source: https://jasonwalton.ca/rust-book-abridged/ch12-io-project-cli

Example of how the grep command is invoked from the terminal.

```bash
$ grep [pattern] [filename]  

```

--------------------------------

### Write documentation comments

Source: https://jasonwalton.ca/rust-book-abridged/ch14-more-about-cargo

Use triple slashes to document public functions and include examples that run as tests.

```rust
/// Adds one to the number given.  
///  
/// # Examples  
///  
/// ```  
/// let arg = 5;  
/// let answer = my_crate::add_one(arg);  
///  
/// assert_eq!(6, answer);  
/// ```  
pub fn add_one(x: i32) -> i32 {  
    x + 1  
}  
```

--------------------------------

### Perform basic HashMap operations in Rust

Source: https://jasonwalton.ca/rust-book-abridged/ch08-common-collections

Demonstrates importing HashMap, inserting key-value pairs, retrieving values with get, and iterating over entries.

```rust
use std::collections::HashMap;  
  
fn main() {  
    let mut scores = HashMap::new();  
  
    // Insert some values into the map  
    scores.insert(String::from("Blue"), 10);  
    scores.insert(String::from("Yellow"), 50);  
  
    // Access values with `get`  
    let team_name = String::from("Blue");  
    let score = scores.get(&team_name).copied().unwrap_or(0);  
  
    // Iterate over the keys with a for loop:  
    for (key, value) in &scores {  
        println!("{key}: {value}");  
    }  
}  
```

--------------------------------

### Use comments and doc comments

Source: https://jasonwalton.ca/rust-book-abridged/ch03-common-programming-concepts

Examples of single-line, block, and documentation comments for functions and modules.

```rust
// This is a comment.  Multi-line comments  
// generally are written this way.  
  
/* You can use this style of comment too. */  
  
/// This is a doc comment for the "next thing", in  
/// this case for the `foo` function.  Markdown is  
/// allowed here.  See chapter 14 for more details.  
fn foo() {}  
  
mod bar {  
    //! This is a doc comment for the "parent thing",  
    //! in this case the "bar" module.  
}  
```

--------------------------------

### Example Program with Approximate Constant

Source: https://jasonwalton.ca/rust-book-abridged/zz-appendix/appendix-04-useful-development-tools

A sample program that triggers a clippy::approx_constant warning.

```rust
fn main() {  
    let x = 3.1415;  
    let r = 8.0;  
    println!("the area of the circle is {}", x * r * r);  
}  
```

--------------------------------

### Lifetime Annotation Syntax Examples

Source: https://jasonwalton.ca/rust-book-abridged/ch10/ch10-03-lifetimes

Demonstrates the syntax for standard references, references with explicit lifetimes, and mutable references with explicit lifetimes.

```rust
&i32        // a reference  
&'a i32     // a reference with an explicit lifetime  
&'a mut i32 // a mutable reference with an explicit lifetime  
```

--------------------------------

### HTTP Response Format

Source: https://jasonwalton.ca/rust-book-abridged/ch20/ch20-01-single-threaded-web-server

Example of a standard HTTP response structure.

```text
HTTP/1.1 200 OK  
Content-Type: text  
Content-Length: 26  
  
<html>Hello, World!</html>  

```

--------------------------------

### Synchronous connection handling loop

Source: https://jasonwalton.ca/rust-book-abridged/ch21-async

An example of a blocking loop that awaits each connection sequentially.

```rust
    loop {  
        let (stream, _) = listener.accept().await.unwrap();  
        handle_connection(stream).await;  
    }  
```

--------------------------------

### Blanket Implementation Example

Source: https://jasonwalton.ca/rust-book-abridged/ch10/ch10-02-traits

Demonstrates how the standard library implements the ToString trait for any type that implements the Display trait.

```rust
impl<T: Display> ToString for T {  
    // --snip--  
}  

```

--------------------------------

### Looping constructs

Source: https://jasonwalton.ca/rust-book-abridged/ch03-common-programming-concepts

Examples of infinite loops, returning values from loops, labeled loops, and while loops.

```rust
loop {  
    println!("Infinite loop!")  
}  
  
// Loops can be used as expressions, with `break`  
// returning the value from the block.  
let mut counter = 0;  
let x = loop {  
    counter += 1;  
    if counter == 10 {  
        break counter * 2;  
    }  
};  
  
// Loops can be labeled with a single quote  
// followed by the label and the a colon.  
'outer: loop {  
    'inner: loop {  
        break 'outer;  
    }  
}  
  
// A while loop looks a lot like a  
// while loop in every other language.  
let mut number = 0;  
while number < 10 {  
    number++;  
}  
```

--------------------------------

### Use the Derive Macro

Source: https://jasonwalton.ca/rust-book-abridged/ch19/ch19-05-macros

Example of applying the custom derive attribute to a struct.

```rust
use hello_macro::HelloMacro;  
use hello_macro_derive::HelloMacro;  
  
// This derive attribute will run our derive macro.  
#[derive(HelloMacro)]  
struct Pancakes;  
  
fn main() {  
    // This will print "Hello, Macro! My name is Pancakes!"  
    Pancakes::hello_macro();  
}  
```

--------------------------------

### Invoke a function-like macro

Source: https://jasonwalton.ca/rust-book-abridged/ch19/ch19-05-macros

Example of calling a procedural macro using function-like syntax.

```rust
let sql = sql!(SELECT * FROM posts WHERE id=1);  
```

--------------------------------

### Consuming Nested Library Modules

Source: https://jasonwalton.ca/rust-book-abridged/ch14-more-about-cargo

Example of how users must import items from deep within the module hierarchy.

```rust
use art::kinds::PrimaryColor;  
use art::utils::mix;  
  
fn main() {  
    let red = PrimaryColor::Red;  
    let yellow = PrimaryColor::Yellow;  
    mix(red, yellow);  
}  
```

--------------------------------

### Static Dispatch Example

Source: https://jasonwalton.ca/rust-book-abridged/ch17-object-oriented-features

Demonstrates static dispatch where the compiler determines the method to call at compile time.

```rust
let button = Button {  
    width: 50,  
    height: 10,  
    label: String::from("OK"),  
};  
  
button.draw();  
```

--------------------------------

### Defining Nested Modules for a Restaurant Library

Source: https://jasonwalton.ca/rust-book-abridged/ch07-packages-crates-modules

An example of organizing code into nested modules representing different areas of a restaurant, defined inline within src/lib.rs.

```rust
mod front_of_house {  
    mod hosting {  
        fn add_to_waitlist() {}  
  
        fn seat_at_table() {}  
    }  
  
    mod serving {  
        fn take_order() {}  
  
        fn serve_order() {}  
  
        fn take_payment() {}  
    }  
}  
```

--------------------------------

### Initialize a workspace directory

Source: https://jasonwalton.ca/rust-book-abridged/ch14-more-about-cargo

Commands to create a root directory for the workspace and initialize it as a git repository.

```bash
$ mkdir add  
$ cd add  
$ git init .  
$ echo "/target" > .gitignore  
```

--------------------------------

### Initialize a new Rust project with Cargo

Source: https://jasonwalton.ca/rust-book-abridged/ch02-guessing-game

Use these commands to create a new directory structure and navigate into it.

```bash
$ cargo new guessing_game  
$ cd guessing_game  
```

--------------------------------

### Initialize a Cargo Project

Source: https://jasonwalton.ca/rust-book-abridged/ch01-getting-started

Create a new project directory structure using the cargo CLI.

```bash
$ cargo new hello_cargo  
$ cd hello_cargo  
```

--------------------------------

### Read vector elements

Source: https://jasonwalton.ca/rust-book-abridged/ch08-common-collections

Access elements using indexing or the get method, noting that indexing can panic while get returns an Option.

```rust
let v = vec![1, 2, 3, 4, 5];  
  
let third = &v[2]; // This is an &i32.  
  
let fourth = v.get(3); // This is an Option<&i32>  

```

--------------------------------

### Initialize a new Rust library project

Source: https://jasonwalton.ca/rust-book-abridged/ch11-automated-tests

Commands to create a new library project using Cargo.

```bash
$ cargo new adder --lib  
$ cd adder  
```

--------------------------------

### Initialize minigrep project

Source: https://jasonwalton.ca/rust-book-abridged/ch12-io-project-cli

Commands to create a new Rust project using Cargo.

```bash
cargo new minigrep  
cd minigrep  

```

--------------------------------

### Initialize Option values

Source: https://jasonwalton.ca/rust-book-abridged/ch06-enums-and-pattern-matching

Shows how to create Option instances, noting that None requires explicit type annotation.

```rust
// No need for `std::Options::Some`, or even `Option::Some`,  
// because these are in the prelude.  
let some_number = Some(5);  
let some_str = Some("Hello");  
  
// Need to explicitly annotate type here, since Rust  
// can't automatically infer what type to use for  
// `T` from `None`.  
let absent_number: Option<i32> = None;  
```

--------------------------------

### Update main.rs to use Config and run

Source: https://jasonwalton.ca/rust-book-abridged/ch12-io-project-cli

Integrates the library components into the main entry point, handling errors with unwrap_or_else and if let.

```rust
use minigrep::Config;  
use std::{env, process};  
  
fn main() {  
    let args: Vec<String> = env::args().collect();  
  
    let config = Config::build(&args).unwrap_or_else(|err| {  
        eprintln!("Problem parsing arguments: {err}");  
        process::exit(1);  
    });  
  
    if let Err(e) = minigrep::run(config) {  
        eprintln!("Application error: {e}");  
        process::exit(1);  
    }  
}  
```

--------------------------------

### Define an attribute-like macro usage

Source: https://jasonwalton.ca/rust-book-abridged/ch19/ch19-05-macros

Example of applying a custom attribute to a function.

```rust
#[route(GET, "/")]  
fn index() {  
```

--------------------------------

### Run Project with Cargo Shortcut

Source: https://jasonwalton.ca/rust-book-abridged/ch01-getting-started

A single command to build and run the project.

```bash
$ cargo run  
```

--------------------------------

### Rectangle struct definition

Source: https://jasonwalton.ca/rust-book-abridged/ch11-automated-tests

A simple struct with a method used for testing examples.

```rust
#[derive(Debug)]  
struct Rectangle {  
    width: u32,  
    height: u32,  
}  
  
impl Rectangle {  
    fn can_hold(&self, other: &Rectangle) -> bool {  
        self.width > other.width && self.height > other.height  
    }  
}  
```

--------------------------------

### Create Consumer Project

Source: https://jasonwalton.ca/rust-book-abridged/ch19/ch19-05-macros

Commands to create a test project that consumes the custom derive macro.

```bash
cd ..  
cargo new pancakes  
```

--------------------------------

### Create workspace packages

Source: https://jasonwalton.ca/rust-book-abridged/ch14-more-about-cargo

Commands to generate the binary and library packages within the workspace.

```bash
$ cargo new adder  
$ cargo new add_one --lib  
$ cargo new add_two --lib  
```

--------------------------------

### Initialize Macro Project Structure

Source: https://jasonwalton.ca/rust-book-abridged/ch19/ch19-05-macros

Commands to create the nested project structure required for a library and its associated derive macro.

```bash
mkdir projects  
cd projects  
cargo new hello_macro --lib  
cd hello_macro  
cargo new hello_macro_derive --lib  
```

--------------------------------

### AST Representation of DeriveInput

Source: https://jasonwalton.ca/rust-book-abridged/ch19/ch19-05-macros

Example of the data structure generated by syn when parsing a struct.

```rust
DeriveInput {  
    // --snip--  
    ident: Ident {  
        ident: "Pancakes",  
        span: #0 bytes(95..103)  
    },  
    data: Struct(  
        DataStruct {  
            struct_token: Struct,  
            fields: Unit,  
            semi_token: Some(  
                Semi  
            )  
        }  
    )  
}  
```

--------------------------------

### Create Hello World in Rust

Source: https://jasonwalton.ca/rust-book-abridged/ch01-getting-started

A basic Rust program that prints to the console.

```rust
fn main() {  
    println!("Hello, world!");  
}  
```

--------------------------------

### Handle connections with tokio::spawn

Source: https://jasonwalton.ca/rust-book-abridged/ch21-async

Demonstrates spawning a task for each connection using a loop and a future returned by handle_connection.

```rust
    loop {  
        let (stream, _) = listener.accept().await.unwrap();  
        let f = handle_connection(stream);  
        tokio::spawn(f);  
    }  
```

--------------------------------

### Defining a Struct

Source: https://jasonwalton.ca/rust-book-abridged/ch03-common-programming-concepts

Example of defining a custom compound type using the struct keyword.

```rust
struct User {  
    name: String,  
    age: u32,  
}  
```

--------------------------------

### Implement the async web server

Source: https://jasonwalton.ca/rust-book-abridged/ch21-async

Main server logic using Tokio's TcpListener and async connection handling.

```rust
use std::{error::Error, time::Duration};  
use tokio::{  
    fs,  
    io::{AsyncBufReadExt, AsyncWriteExt, BufReader},  
    net::{TcpListener, TcpStream},  
};  
  
#[tokio::main]  
async fn main() -> Result<(), Box<dyn Error>> {  
    let port = 7878u16;  
    let listen_address = format!("127.0.0.1:{port}");  
    let listener = TcpListener::bind(listen_address).await.unwrap();  
    println!("Listening on port {}", port);  
  
    loop {  
        let (stream, _) = listener.accept().await.unwrap();  
        handle_connection(stream).await;  
    }  
}  
  
async fn handle_connection(mut stream: TcpStream) {  
    let buf_reader = BufReader::new(&mut stream);  
  
    let mut lines = buf_reader.lines();  
    let request_line = lines.next_line().await.unwrap().unwrap();  
  
    println!("Incoming request for {}", request_line);  
  
    match &request_line[..] {  
        "GET / HTTP/1.1" => send_response(stream, 200, "OK", "hello.html").await,  
        "GET /sleep HTTP/1.1" => {  
            tokio::time::sleep(Duration::from_secs(5)).await;  
            send_response(stream, 200, "OK", "hello.html").await;  
        }  
        _ => send_response(stream, 404, "NOT FOUND", "404.html").await,  
    }  
}  
  
async fn send_response(mut stream: TcpStream, code: u16, reason: &str, filename: &str) {  
    let contents = fs::read_to_string(filename).await.unwrap();  
    let length = contents.len();  
    let response =  
        format!("HTTP/1.1 {code} {reason}\r\nContent-Length: {length}\r\n\r\n{contents}");  
  
    stream.write_all(response.as_bytes()).await.unwrap();  
}  
```

--------------------------------

### Original Config build implementation

Source: https://jasonwalton.ca/rust-book-abridged/ch13-functional-language-features

The initial implementation of the Config struct using a slice of Strings and manual cloning.

```rust
impl Config {  
    pub fn build(args: &[String]) -> Result<Config, &'static str> {  
        if args.len() < 3 {  
            return Err("not enough arguments");  
        }  
  
        let query = args[1].clone(); // <= Ugly clone! It hurts us!  
        let file_path = args[2].clone();  
  
        let ignore_case = env::var("IGNORE_CASE").is_ok();  
  
        Ok(Config {  
            query,  
            file_path,  
            ignore_case,  
        })  
    }  
}  
```

--------------------------------

### Invalid ? usage in main

Source: https://jasonwalton.ca/rust-book-abridged/ch09-error-handling

Shows an example that fails to compile because the ? operator is used in a function returning unit.

```rust
use std::fs::File;  
  
fn main() {  
    // Can't use `?` here!  
    let greeting_file = File::open("hello.txt")?;  
}  
```

--------------------------------

### Defining Tests in Rust

Source: https://jasonwalton.ca/rust-book-abridged/ch11-automated-tests

Example of a library module with multiple test functions using the test attribute.

```rust
pub fn add_two(a: i32) -> i32 {  
    a + 2  
}  
  
#[cfg(test)]  
mod tests {  
    use super::*;  
  
    #[test]  
    fn add_two_and_two() {  
        assert_eq!(4, add_two(2));  
    }  
  
    #[test]  
    fn add_three_and_two() {  
        assert_eq!(5, add_two(3));  
    }  
  
    #[test]  
    fn one_hundred() {  
        assert_eq!(102, add_two(100));  
    }  
}  
```

--------------------------------

### Reference mutability combinations

Source: https://jasonwalton.ca/rust-book-abridged/ch04-ownership

Examples of how the mut keyword affects whether a reference can modify the target or be reassigned.

```rust
// x1 is a reference to y.  We can't update x or y:  
let x1 = &y;  
// x2 is a reference that can be used to change y:  
let x2 = &mut y;  
// x3 is is a reference that currently points to,  
// an immutable y, but we could change x3 to point  
// somewhere else.  
let mut x3 = &y;  
// x4 is a reference that can be used to change y,  
// and can also be updated to point somewhere else.  
let mut x4 = &mut y;  

```

--------------------------------

### Build the workspace

Source: https://jasonwalton.ca/rust-book-abridged/ch14-more-about-cargo

Command to build all packages within the workspace.

```bash
$ cargo build  
   Compiling add_two v0.1.0 (add/add_two)  
   Compiling adder v0.1.0 (add/adder)  
   Compiling add_one v0.1.0 (add/add_one)  
    Finished dev [unoptimized + debuginfo] target(s) in 0.11s  
```

--------------------------------

### Create a new String

Source: https://jasonwalton.ca/rust-book-abridged/ch08-common-collections

Initialize an empty String using the new method.

```rust
let mut s = String::new();
```

--------------------------------

### Invalid closure usage with FnMut

Source: https://jasonwalton.ca/rust-book-abridged/ch13-functional-language-features

An example of a closure that fails to compile because it moves a captured value, restricting it to FnOnce.

```rust
let mut sort_operations = vec![];  
let value = String::from("by key called");  
  
// This doesn't compile!  
list.sort_by_key(|r| {  
    sort_operations.push(value);  
    r.width  
});  
```

--------------------------------

### Displaying Cargo Test Help

Source: https://jasonwalton.ca/rust-book-abridged/ch11-automated-tests

View help documentation for the cargo test command or the underlying test runner.

```bash
$ cargo test --help  
$ cargo test -- --help  
```

--------------------------------

### Build and Run with Cargo

Source: https://jasonwalton.ca/rust-book-abridged/ch01-getting-started

Commands to build the project and execute the binary from the debug target directory.

```bash
$ cargo build  
$ ./target/debug/hello_cargo  
```

--------------------------------

### Implement an integration test

Source: https://jasonwalton.ca/rust-book-abridged/ch11-automated-tests

Demonstrates how to import the library crate and write a test function in an integration test file.

```rust
use adder;  
  
#[test]  
fn it_adds_two() {  
    assert_eq!(4, adder::add_two(2));  
}  
```

--------------------------------

### Handle file opening with match

Source: https://jasonwalton.ca/rust-book-abridged/ch09-error-handling

Basic usage of match to handle the Result returned by File::open.

```rust
use std::fs::File;  
  
fn main() {  
    let greeting_file_result = File::open("hello.txt");  
  
    let greeting_file = match greeting_file_result {  
        Ok(file_obj) => file_obj,  
        Err(error) => panic!("Problem opening the file: {:?}", error),  
    };  
}  
```

--------------------------------

### Demonstrating ownership conflict with Box<T>

Source: https://jasonwalton.ca/rust-book-abridged/ch15-smart-pointers

This example illustrates why Box<T> cannot be used for multiple ownership, as it moves the value into the new structure.

```rust
enum List {  
    Cons(i32, Box<List>),  
    Nil,  
}  
  
use crate::List::{Cons, Nil};  
  
fn main() {  
    let a = Cons(5, Box::new(Cons(10, Box::new(Nil))));  
    let b = Cons(3, Box::new(a));  
    let c = Cons(4, Box::new(a)); // This doesn't work!  
}  
```

--------------------------------

### Implicit Deref Coercion Example

Source: https://jasonwalton.ca/rust-book-abridged/ch15-smart-pointers

Demonstrates passing a &String to a function expecting a &str, which works due to deref coercion.

```rust
fn hello(name: &str) {  
    println!("Hello, {name}!");  
}  
  
fn main() {  
    let x = String::from("Rust");  
    hello(&x);  
}  
```

--------------------------------

### Rust Web Server Implementation

Source: https://jasonwalton.ca/rust-book-abridged/ch20/ch20-01-single-threaded-web-server

Main server logic using TcpListener to handle incoming connections and serve files.

```rust
use std::{  
    fs,  
    io::{prelude::*, BufReader},  
    net::{TcpListener, TcpStream},  
};  
  
fn main() {  
    let port = 7878u16;  
    let listen_address = format!("127.0.0.1:{port}");  
    let listener = TcpListener::bind(listen_address).unwrap();  
  
    println!("Listening on port {}", port);  
  
    for stream in listener.incoming() {  
        let stream = stream.unwrap();  
  
        handle_connection(stream);  
    }  
}  
  
fn handle_connection(mut stream: TcpStream) {  
    let buf_reader = BufReader::new(&mut stream);  
  
    // A line could be an error if it contains invalid  
    // UTF-8, or if there's a problem reading from the  
    // underlying stream.  We ignore these errors here.  
    let http_request: Vec<_> = buf_reader  
        .lines()  
        .map(|result| result.unwrap())  
        .take_while(|line| !line.is_empty()) // Blank line is end of headers.  
        .collect();  
  
    let request_line = &http_request[0];  
  
    println!("Incoming request for {}", request_line);  
  
    if request_line == "GET / HTTP/1.1" {  
        send_response(stream, 200, "OK", "hello.html");  
    } else {  
        send_response(stream, 404, "NOT FOUND", "404.html");  
    }  
}  
  
fn send_response(mut stream: TcpStream, code: u16, reason: &str, filename: &str) {  
    let contents = fs::read_to_string(filename).unwrap();  
    let length = contents.len();  
    let response =  
        format!("HTTP/1.1 {code} {reason}\r\nContent-Length: {length}\r\n\r\n{contents}");  
  
    stream.write_all(response.as_bytes()).unwrap();  
}  

```

--------------------------------

### Example code with unused variable

Source: https://jasonwalton.ca/rust-book-abridged/zz-appendix/appendix-04-useful-development-tools

Sample Rust code containing an unused loop variable that triggers a compiler warning.

```rust
fn do_something() {}  
  
fn main() {  
    for i in 0..100 {  
        do_something();  
    }  
}  
```

--------------------------------

### Navigating the module tree with super

Source: https://jasonwalton.ca/rust-book-abridged/ch07-packages-crates-modules

Shows how to access items in a parent module using the super keyword.

```rust
fn deliver_order() {}  
  
mod back_of_house {  
    fn fix_incorrect_order() {  
        cook_order();  
        // Call into `deliver_order` in the parent module.
        super::deliver_order();  
    }  
  
    fn cook_order() {}  
}  
```

--------------------------------

### Using ? with Option

Source: https://jasonwalton.ca/rust-book-abridged/ch09-error-handling

Demonstrates using the ? operator to return early if an Option is None.

```rust
fn last_char_of_first_line(text: &str) -> Option<char> {  
    text.lines().next()?.chars().last()  
}  
```

--------------------------------

### Define and use a simple declarative macro

Source: https://jasonwalton.ca/rust-book-abridged/ch19/ch19-05-macros

Demonstrates a basic macro definition with an empty matcher and its subsequent invocation.

```rust
macro_rules! four {  
    () => {  
        1 + 3  
    };  
}  
  
fn main() {  
    let x = four!();  
    println!("{x}");  
}  
```

--------------------------------

### Demonstrating thread ownership errors

Source: https://jasonwalton.ca/rust-book-abridged/ch16-fearless-concurrency

An example that fails to compile because the spawned thread attempts to borrow a variable that may be dropped by the main thread.

```rust
use std::thread;  
  
fn main() {  
    let v = vec![1, 2, 3];  
  
    // This doesn't work!  
    let handle = thread::spawn(|| {  
        println!("Here's a vector: {:?}", v);  
    });  
  
    drop(v);  
  
    handle.join().unwrap();  
}  
```

--------------------------------

### Invalid vector mutation example

Source: https://jasonwalton.ca/rust-book-abridged/ch08-common-collections

Demonstrates a compilation error caused by holding a reference to an element while pushing to the vector, which may trigger reallocation.

```rust
let mut v = vec![1, 2, 3, 4, 5];  
  
let first = &v[0];  
  
v.push(6); // This will fail to compile!  
  
println!("The first element is: {first}");  

```

--------------------------------

### Sharing data with Rc<T>

Source: https://jasonwalton.ca/rust-book-abridged/ch15-smart-pointers

This example uses Rc<T> to allow multiple lists to share the same tail, incrementing the reference count instead of moving ownership.

```rust
enum List {  
    Cons(i32, Rc<List>),  
    Nil,  
}  
  
use crate::List::{Cons, Nil};  
use std::rc::Rc;  
  
fn main() {  
    let a = Rc::new(Cons(5, Rc::new(Cons(10, Rc::new(Nil)))));  
    let b = Cons(3, Rc::clone(&a));  
    let c = Cons(4, Rc::clone(&a));  
  
    println!("count after creating c = {}", Rc::strong_count(&a));  
}  
```

--------------------------------

### Struct with a single lifetime for multiple fields

Source: https://jasonwalton.ca/rust-book-abridged/ch10/ch10-03-lifetimes

An example of a struct definition that forces both fields to share the same lifetime, which can lead to compilation errors if scopes differ.

```rust
struct Point<'a> {  
    x: &'a i32,  
    y: &'a i32,  
}  
```

--------------------------------

### Demonstrating a lifetime-related compilation error

Source: https://jasonwalton.ca/rust-book-abridged/ch10/ch10-03-lifetimes

This example illustrates a function that returns a reference which may outlive one of its inputs, leading to a potential use-after-free error.

```rust
fn biggest(x: &i32, y: &i32) -> &i32 {  
    if *x > *y {  
        x  
    } else {  
        y  
    }  
}  
  
fn main() {  
    let i1 = 7;  
    let result;  
  
    {  
        let i2 = 8;  
        result = biggest(&i1, &i2);  
    }  
  
    // This shouldn't compile! But how does rust know that?  
    println!("The bigger value is {}", result);  
}  
```

--------------------------------

### Asynchronous file reading in JavaScript

Source: https://jasonwalton.ca/rust-book-abridged/ch21-async

Demonstrates reading a file asynchronously using the async/await syntax.

```javascript
// JavaScript Code  
import * as fs from "fs/promises";  
  
async function getUserName() {  
  const username = await fs.readFile("./username.txt", { encoding: "utf-8" });  
  console.log(`Hello ${username}`);  
}  
```

--------------------------------

### Spawning a new thread with thread::spawn

Source: https://jasonwalton.ca/rust-book-abridged/ch16-fearless-concurrency

Demonstrates creating a new OS thread using a closure and waiting for its completion with a join handle.

```rust
use std::thread;  
use std::time::Duration;  
  
fn main() {  
    let handle = thread::spawn(|| {  
        for i in 1..10 {  
            println!("hi number {} from the spawned thread!", i);  
            thread::sleep(Duration::from_millis(1));  
        }  
    });  
  
    for i in 1..5 {  
        println!("hi number {} from the main thread!", i);  
        thread::sleep(Duration::from_millis(1));  
    }  
  
    handle.join().unwrap();  
}  
```

--------------------------------

### Implement and Use Custom Components

Source: https://jasonwalton.ca/rust-book-abridged/ch17-object-oriented-features

Shows how a library user can define their own component and use it alongside existing components within the 'Screen' struct.

```rust
use gui::{Button, Screen};  
  
// Define a custom SelectBox component, not  
// in the gui library.  
struct SelectBox {  
    width: u32,  
    height: u32,  
    options: Vec<String>,  
}  
  
impl Draw for SelectBox {  
    fn draw(&self) {  
        // code to actually draw a select box  
    }  
}  
  
fn main() {  
    let screen = Screen {  
        components: vec![  
            Box::new(SelectBox {  
                width: 75,  
                height: 10,  
                options: vec![  
                    String::from("Yes"),  
                    String::from("Maybe"),  
                    String::from("No"),  
                ],  
            }),  
            Box::new(Button {  
                width: 50,  
                height: 10,  
                label: String::from("OK"),  
            }),  
        ],  
    };  
  
    screen.run();  
}  
```

--------------------------------

### Test post workflow

Source: https://jasonwalton.ca/rust-book-abridged/ch17-object-oriented-features

Unit test demonstrating the state transition workflow from draft to approved post.

```rust
#[cfg(test)]  
mod tests {  
    use super::*;  
  
    #[test]  
    fn post_workflow() {  
        let mut post = Post::new();  
  
        post.add_text("I ate a salad for lunch today");  
  
        let post = post.request_review();  
  
        let post = post.approve();  
        assert_eq!("I ate a salad for lunch today", post.content());  
    }  
}  
```

--------------------------------

### Configure Cargo.toml dependencies

Source: https://jasonwalton.ca/rust-book-abridged/ch21-async

Add the Tokio runtime with full features to the project configuration.

```toml
[package]  
name = "hello-async"  
version = "0.1.0"  
edition = "2021"  
  
[dependencies]  
tokio = { version = "1", features = ["full"] }  
```

--------------------------------

### Read command line arguments in main.rs

Source: https://jasonwalton.ca/rust-book-abridged/ch12-io-project-cli

Basic implementation to capture and print command line arguments.

```rust
use std::env;  
  
fn main() {  
    let args: Vec<String> = env::args().collect();  
  
    // &args[0] is the name of the binary  
    // e.g. target/debug/minigrep  
    let query = &args[1];  
    let file_path = &args[2];  
  
    println!("Searching for {}", query);  
    println!("In file {}", file_path);  
}  

```

--------------------------------

### Post Workflow Unit Test

Source: https://jasonwalton.ca/rust-book-abridged/ch17-object-oriented-features

Defines the expected API and state transition workflow for the blogging server.

```rust
#[cfg(test)]  
mod tests {  
    use super::*;  
  
    #[test]  
    fn post_workflow() {  
        let mut post = Post::new();  
  
        post.add_text("I ate a salad for lunch today");  
        assert_eq!("", post.content());  
  
        post.request_review();  
        assert_eq!("", post.content());  
  
        post.approve();  
        assert_eq!("I ate a salad for lunch today", post.content());  
    }  
}  
```

--------------------------------

### View workspace directory structure

Source: https://jasonwalton.ca/rust-book-abridged/ch14-more-about-cargo

The expected file layout for a workspace containing multiple packages.

```text
├── .git  
├── .gitignore  
├── Cargo.lock  
├── Cargo.toml  
├── add_one  
│   ├── Cargo.toml  
│   └── src  
│       └── lib.rs  
├── add_two  
│   ├── Cargo.toml  
│   └── src  
│       └── lib.rs  
├── adder  
│   ├── Cargo.toml  
│   └── src  
│       └── main.rs  
└── target  
```

--------------------------------

### Document crates and modules

Source: https://jasonwalton.ca/rust-book-abridged/ch14-more-about-cargo

Use the //! syntax to document the parent item, such as the crate root or a module.

```rust
//! # My Crate  
//!  
//! `my_crate` is a collection of utilities to make performing certain  
//! calculations more convenient.  
  
/// Adds one to the number given.  
// --snip--  
```

--------------------------------

### Run Clippy

Source: https://jasonwalton.ca/rust-book-abridged/zz-appendix/appendix-04-useful-development-tools

Execute clippy lints on a Cargo project.

```bash
$ cargo clippy  
```

--------------------------------

### Implement state transitions for posts

Source: https://jasonwalton.ca/rust-book-abridged/ch17-object-oriented-features

Adds PendingReviewPost and transition methods to move between post states.

```rust
// --snip--  
  
impl DraftPost {  
    // --snip--  
  
    pub fn request_review(self) -> PendingReviewPost {  
        PendingReviewPost {  
            content: self.content,  
        }  
    }  
}  
  
pub struct PendingReviewPost {  
    content: String,  
}  
  
impl PendingReviewPost {  
    pub fn approve(self) -> Post {  
        Post {  
            content: self.content,  
        }  
    }  
}  
```

--------------------------------

### Configure Procedural Macro Dependencies

Source: https://jasonwalton.ca/rust-book-abridged/ch19/ch19-05-macros

Cargo.toml configuration for a procedural macro library.

```toml
[lib]  
proc-macro = true  
  
[dependencies]  
syn = "1.0"  
quote = "1.0"  
```

--------------------------------

### Using Field Init Shorthand

Source: https://jasonwalton.ca/rust-book-abridged/ch05-structs

Simplifies struct initialization when variable names match field names.

```rust
fn build_user(email: String, username: String) -> User {  
    User {  
        active: true,  
        // Instead of `username: username,` we can do:  
        username,  
        email,  
        sign_in_count: 1,  
    }  
}  
```

--------------------------------

### Compile and Run Rust Manually

Source: https://jasonwalton.ca/rust-book-abridged/ch01-getting-started

Compile a source file using rustc and execute the resulting binary.

```bash
$ rustc main.rs  
$ ./main  
Hello, world!  
```

--------------------------------

### Run workspace binary

Source: https://jasonwalton.ca/rust-book-abridged/ch14-more-about-cargo

Command to execute the binary package within the workspace.

```bash
$ cargo run  
    Finished dev [unoptimized + debuginfo] target(s) in 0.00s  
     Running `target/debug/adder`  
Hello, world! 10 plus one is 11!  
```

--------------------------------

### Array Declaration and Access

Source: https://jasonwalton.ca/rust-book-abridged/ch03-common-programming-concepts

Shows how to initialize arrays, destructure them, access elements by index, and create arrays with repeated values.

```rust
let a = [1, 2, 3, 4, 5];  
  
// Destructuring assignment.  Must use all elements!  
let [x, y, z, _, _] = a;  
  
// Access individual elements  
let first = a[0];  
let second = a[1];  
  
// Create array of type i32, length 5.  
let b: [i32; 5] = [1, 2, 3, 4, 5];  
  
// Create array of five zeros.  
let c = [0; 5]  
```

--------------------------------

### Basic Message Passing with mpsc

Source: https://jasonwalton.ca/rust-book-abridged/ch16-fearless-concurrency

Demonstrates creating a channel and sending a single value from a spawned thread to the main thread.

```rust
use std::sync::mpsc;  
use std::thread;  
  
fn main() {  
    let (tx, rx) = mpsc::channel();  
  
    thread::spawn(move || {  
        let val = String::from("hi");  
        tx.send(val).unwrap();  
    });  
  
    let received = rx.recv().unwrap();  
    println!("Got: {}", received);  
}  
```

--------------------------------

### Using the dbg! macro

Source: https://jasonwalton.ca/rust-book-abridged/ch05-structs

Demonstrates using the dbg! macro to print a value along with its source file and line number.

```rust
[src/main.rs:13] &rect1 = Rectangle {  
    width: 30,  
    height: 50,  
}  
```

--------------------------------

### Importing modules with use

Source: https://jasonwalton.ca/rust-book-abridged/ch07-packages-crates-modules

Brings a child module into the current scope to simplify path references.

```rust
use crate::front_of_house::hosting;  
  
mod front_of_house {  
    pub mod hosting {  
        pub fn add_to_waitlist() {}  
    }  
}  
  
pub fn eat_at_restaurant() {  
    // Don't need to write `front_of_house::hosting::add_to_waitlist()`  
    // here because we brought `hosting` into scope with the `use`  
    // above.use crate::front_of_house::hosting;  
  
    hosting::add_to_waitlist();  
}  
```

--------------------------------

### Test module with passing and failing tests

Source: https://jasonwalton.ca/rust-book-abridged/ch11-automated-tests

Demonstrates how to write multiple tests, including one that triggers a panic.

```rust
#[cfg(test)]  
mod tests {  
    #[test]  
    fn exploration() {  
        assert_eq!(2 + 2, 4);  
    }  
  
    #[test]  
    fn another() {  
        panic!("Sad trombone");  
    }  
}  
```

--------------------------------

### Define and call methods on a struct

Source: https://jasonwalton.ca/rust-book-abridged/ch05-structs

Demonstrates defining a struct and implementing methods within an impl block, including a method that takes a reference to another instance.

```rust
#[derive(Debug)]  
struct Rectangle {  
    width: u32,  
    height: u32,  
}  
  
impl Rectangle {  
    fn area(&self) -> u32 {  
        self.width * self.height  
    }  
  
    // Returns true if `other` Rectangle can fit inside this one.  
    fn can_hold(&self, other: &Rectangle) -> bool {  
        self.width > other.width && self.height > other.height  
    }  
}  
  
fn main() {  
    let rect1 = Rectangle {  
        width: 30,  
        height: 50,  
    };  
  
    println!(  
        "The area of the rectangle is {} square pixels.",  
        rect1.area()  
    );  
}  
```

--------------------------------

### Tuple Declaration and Access

Source: https://jasonwalton.ca/rust-book-abridged/ch03-common-programming-concepts

Demonstrates how to define a tuple, destructure it into variables, and access elements using dot notation.

```rust
let tup: (i32, f64, u8) = (800, 6.4, 1);  
  
// Destructuring assignment  
let (x, y, z) = tup;  
  
// Access individual elements  
let a = tup.0;  
let b = tup.1;  
let c = tup.2;  
```

--------------------------------

### Run minigrep with arguments

Source: https://jasonwalton.ca/rust-book-abridged/ch12-io-project-cli

Executing the program via cargo with arguments passed after the double dash.

```bash
$ cargo run -- query file.txt  
...  
Searching for query  
In file file.txt  

```

--------------------------------

### Publishing a Crate

Source: https://jasonwalton.ca/rust-book-abridged/ch14-more-about-cargo

Command to upload the current crate version to crates.io.

```bash
$ cargo publish  
```

--------------------------------

### HTML Files for Server

Source: https://jasonwalton.ca/rust-book-abridged/ch20/ch20-01-single-threaded-web-server

HTML content to be served by the web server.

```html
<!DOCTYPE html>  
<html lang="en">  
  <head>  
    <meta charset="utf-8" />  
    <title>Hello!</title>  
  </head>  
  <body>  
    <h1>Hello!</h1>  
    <p>Hi from Rust</p>  
  </body>  
</html>  

```

```html
<!DOCTYPE html>  
<html lang="en">  
  <head>  
    <meta charset="utf-8" />  
    <title>Hello!</title>  
  </head>  
  <body>  
    <h1>Oops!</h1>  
    <p>Sorry, I don't know what you're asking for.</p>  
  </body>  
</html>  

```

--------------------------------

### Using the custom MyBox smart pointer

Source: https://jasonwalton.ca/rust-book-abridged/ch15-smart-pointers

Demonstrates using the custom MyBox type with the dereference operator.

```rust
fn main() {  
    let x = 5;  
    let y = MyBox::new(x);  
  
    assert_eq!(5, x);  
    assert_eq!(5, *y);  
}  
```

--------------------------------

### Request Review State Transition

Source: https://jasonwalton.ca/rust-book-abridged/ch17-object-oriented-features

Uses Option::take to safely transition the state of a Post by taking ownership of the current state.

```rust
    pub fn request_review(&mut self) {  
        if let Some(s) = self.state.take() {  
            self.state = Some(s.request_review())  
        }  
    }  
```

--------------------------------

### LimitTracker Implementation

Source: https://jasonwalton.ca/rust-book-abridged/ch15-smart-pointers

Logic for tracking quota usage and triggering messenger alerts based on percentage thresholds.

```rust
pub struct LimitTracker<'a, T: Messenger> {  
    messenger: &'a T,  
    value: usize,  
    max: usize,  
}  
  
impl<'a, T> LimitTracker<'a, T>  
where  
    T: Messenger,  
{  
    pub fn new(messenger: &'a T, max: usize) -> LimitTracker<'a, T> {  
        LimitTracker {  
            messenger,  
            value: 0,  
            max,  
        }  
    }  
  
    pub fn set_value(&mut self, value: usize) {  
        self.value = value;  
  
        let percentage_of_max = self.value as f64 / self.max as f64;  
  
        if percentage_of_max >= 1.0 {  
            self.messenger.send("Error: You are over your quota!");  
        } else if percentage_of_max >= 0.9 {  
            self.messenger  
                .send("Urgent warning: You've used up over 90% of your quota!");  
        } else if percentage_of_max >= 0.75 {  
            self.messenger  
                .send("Warning: You've used up over 75% of your quota!");  
        }  
    }  
}  
```

--------------------------------

### Implement Inventory Giveaway with Closures

Source: https://jasonwalton.ca/rust-book-abridged/ch13-functional-language-features

Demonstrates using a closure with unwrap_or_else to provide a fallback value when an Option is None.

```rust
#[derive(Debug, PartialEq, Copy, Clone)]  
enum ShirtColor {  
    Red,  
    Blue,  
}  
  
struct Inventory {  
    // A vector of shirt colors, one for each shirt we have in stock.  
    shirts: Vec<ShirtColor>,  
}  
  
impl Inventory {  
    /// Figure out what color of shirt to give away.  
    fn giveaway(&self, user_preference: Option<ShirtColor>) -> ShirtColor {  
        user_preference.unwrap_or_else(|| self.most_stocked())  
    }  
  
    // Figure out what shirt color we have the most of in inventory.  
    fn most_stocked(&self) -> ShirtColor {  
        let mut num_red = 0;  
        let mut num_blue = 0;  
  
        for color in &self.shirts {  
            match color {  
                ShirtColor::Red => num_red += 1,  
                ShirtColor::Blue => num_blue += 1,  
            }  
        }  
        if num_red > num_blue {  
            ShirtColor::Red  
        } else {  
            ShirtColor::Blue  
        }  
    }  
}  
  
fn main() {  
    let store = Inventory {  
        shirts: vec![ShirtColor::Blue, ShirtColor::Red, ShirtColor::Blue],  
    };  
  
    let user_pref1 = Some(ShirtColor::Red);  
    let giveaway1 = store.giveaway(user_pref1);  
    println!(  
        "The user with preference {:?} gets {:?}",  
        user_pref1, giveaway1  
    );  
  
    let user_pref2 = None;  
    let giveaway2 = store.giveaway(user_pref2);  
    println!(  
        "The user with preference {:?} gets {:?}",  
        user_pref2, giveaway2  
    );  
}  
```

--------------------------------

### Configure Consumer Dependencies

Source: https://jasonwalton.ca/rust-book-abridged/ch19/ch19-05-macros

Cargo.toml configuration for the consumer project to link the trait and macro crates.

```toml
[dependencies]  
hello_macro = { path = "../hello_macro" }  
hello_macro_derive = { path = "../hello_macro/hello_macro_derive" }  
```

--------------------------------

### Configuring Crate Metadata

Source: https://jasonwalton.ca/rust-book-abridged/ch14-more-about-cargo

Required fields in Cargo.toml for publishing a crate to crates.io.

```toml
[package]  
name = "my_awesome_colors"  
version = "0.1.0"  
edition = "2021"  
description = "A fancy awesome crate for generating colored text in the terminal."  
license = "MIT"  
```

--------------------------------

### Define a function with parameters

Source: https://jasonwalton.ca/rust-book-abridged/ch03-common-programming-concepts

Demonstrates the syntax for defining a function with typed parameters in Rust.

```rust
fn another_function(x: i32, y: i32) {  
    println!("The point is at: {x}, {y}");  
}  
```
Tokens:
Raw