DEV Community: Oludayo Adeoye

🦀 Rust Master Class - Chapter 26: Performance

Oludayo Adeoye — Thu, 03 Sep 2026 06:34:16 +0000

🦀 Rust Master Class - Chapter 26: Performance

Marathon finish line. Didn't win, but beat my PB by 30 seconds. Those seconds came from a thousand small decisions. Performance isn't one big thing — it's a thousand small ones.

Measuring and improving performance in Rust involves a combination of accurate benchmarking to identify bottlenecks and the application of specific coding patterns to minimize memory allocations and maximize execution speed.

1. Measuring Performance: Benchmarking

To accurately measure code performance, the Criterion crate is the standard tool used in the Rust ecosystem. It provides detailed statistics and allows you to compare different implementations of the same logic .

Key Concept: Benchmarking should be done using a dedicated harness to account for CPU thermal throttling and background noise.
Configuration: You must add Criterion to your dev-dependencies in Cargo.toml and define a benchmark target .

Code Example (Comparing Sorting Algorithms):

// sorting_benchmark.rs
use criterion::{criterion_group, criterion_main, Criterion};
use learning_rust::{sort_algo_1, sort_algo_2};

fn sort_benchmark(c: &mut Criterion) {
    // Create a mutable variable
    let mut numbers = vec![3-10];
    // Compares the execution time of two different sorting implementations
    // Make an independent copy
    c.bench_function("sort_algo_1", |b| b.iter(|| sort_algo_1(&mut numbers.clone())));
    // Make an independent copy
    c.bench_function("sort_algo_2", |b| b.iter(|| sort_algo_2(&mut numbers.clone())));
}

criterion_group!(benches, sort_benchmark);
criterion_main!(benches);

[Source: 172, 173]

2. Minimizing Memory Allocations

Unnecessary heap allocations are a primary source of performance degradation. Rust provides several ways to avoid them.

with_capacity: When creating a collection like a Vec, using with_capacity instead of new prevents the performance hit of multiple reallocations as the collection grows .
Avoiding Re-allocations with std::mem: Instead of cloning or creating new objects, use swap, take, or replace to move data out of a mutable location and put a default or new value in its place .

Code Example (Using swap):

use std::mem::swap;

fn main() {
    // Create a mutable variable
    let mut text = "the developer".to_string();
    // Create a mutable variable
    let mut copied_text = "developer".to_string();
    // Swaps the contents of text and copied_text without re-allocating memory
    swap(&mut text, &mut copied_text); 
}

[Source: 12, 355]

3. Efficient Function Inputs and Coercion

To make functions more flexible and performant, use slices (&str or &[T]) rather than owned collections (&String or &Vec<T>).

Deref Coercion: Slices allow for deref coercion, meaning the function can accept both a slice and a reference to the owned type without extra allocation .
Performance Gain: This avoids unnecessary "double redirection" (e.g., a reference to a Box that contains a string) .

Code Example:

// More efficient: accepts &str (slice) and &String (via coercion)
fn vowels(word: &str) -> u8 { 
    // processing logic
    0
}

fn main() {
    // Create a new variable
    let s = String::from("Rust");
    vowels(&s);      // Works via coercion
    vowels("Rust");  // Works directly
}

[Source: 53, 54, 100, 285]

4. Optimizing Data Structures

Boxing Large Enum Variants: The size of an enum is determined by its largest variant. If one variant is significantly larger than others, it "bloats" the entire enum . By wrapping the large variant in a Box, the enum only stores a pointer, significantly reducing its memory footprint on the stack .
Static vs. Dynamic Dispatch: Use Static Dispatch (Generics with Trait Bounds) whenever possible. The compiler generates specific code for each type used, which allows for inlining and is generally faster than Dynamic Dispatch (&dyn Trait), which relies on a vtable lookup at runtime [18-20].

Code Example (Static Dispatch):

trait Print { fn print(&self); }

// Faster: Resolved at compile time
fn static_display<T: Print>(value: T) {
    value.print();
}

[Source: 33, 133, 283]

5. Efficient Programming Tips

Initialization: Use the Default trait and struct update syntax (..Default::default()) to initialize only the necessary fields of a struct efficiently .
Performance Lints: Utilize Rust’s performance lints to catch common sub-optimal patterns during development .
String Concatenation: Be mindful of ownership when concatenating strings to avoid unnecessary copies; the format! macro is often useful for combining data into a new string without taking ownership of the inputs .

📖 Download the full PDF: https://drive.google.com/file/d/13Ui9FWMikWqjRVx4l3V6aYibXOn9ehHC/view?usp=sharing

Part 26 of the Rust Master Class series — STEM EdTech | Automation Consulting | Rust Tutoring

RustLang #Programming #LearnToCode #STEM #EdTech

📚 Practice Resources

GitHub Repository: https://github.com/PacktPublishing/Rust-Programming-Master-Class-from-Beginner-to-Expert

Try it yourself: https://play.rust-lang.org/

Run the code from this chapter in the Rust playground, then clone the repo to continue your Rust journey!

Part 26 of the Rust Master Class series — STEM EdTech | Automation Consulting | Rust Tutoring

RustLang #Programming #LearnToCode #STEM #EdTech

🦀 Rust Master Class - Chapter 25: Web Programming

Oludayo Adeoye — Thu, 03 Sep 2026 06:33:39 +0000

🦀 Rust Master Class - Chapter 25: Web Programming

He was building a home for his parents. Something accessible, safe, that feels like home. That's what web programming in Rust is — building for someone else.

Web programming in Rust, as detailed in the sources, often begins with low-level networking using the standard library's networking modules to build custom servers from scratch. Key concepts include managing listeners, parsing HTTP requests, and handling concurrency to serve multiple clients simultaneously.

1. Basic Server Setup

The foundation of a web server in Rust is the TcpListener, which binds to a specific IP address and port to listen for incoming traffic . Each incoming connection is represented as a TcpStream .

Code Example: Binding a Listener

use std::net::TcpListener;

fn main() {
    // Bind the listener to a local address
    // Create a new variable
    let listener = TcpListener::bind("127.0.0.1:8000").unwrap();

    // Iterate over incoming connection attempts
    for stream in listener.incoming() {
    // Create a new variable
        let stream = stream.unwrap();
        handle_connection(stream);
    }
}

[Source: 165, 166]

2. Handling the Request-Response Cycle

To process data from a client, you use a BufReader to read the stream and parse the HTTP request . Responses must follow the specific HTTP syntax: HTTP-Version Status-Code Reason-Phrase CRLF headers CRLF message-body .

Request Parsing: You can extract the first line of the request (the "request line") to determine the HTTP method and path .
Writing Responses: Use format! to construct the response string, then use write_all and flush to send the data back to the client .

Code Example: Routing and Responses

use std::io::{BufRead, BufReader, Write};
use std::fs;
use std::net::TcpStream;

fn handle_connection(mut stream: TcpStream) {
    let buf_reader = BufReader::new(&mut stream);
    // Get the first line of the request
    // Create a new variable
    let request_line = buf_reader.lines().next().unwrap().unwrap();

    // Routing logic using match
    // Create a new variable
    let (status_line, file_name) = match request_line.as_str() {
        "GET / HTTP/1.1" => ("HTTP/1.1 200 OK\r\input", "index.html"),
        _ => ("HTTP/1.1 404 NOT FOUND\r\input", "404.html"),
    };

    // Create a new variable
    let contents = fs::read_to_string(file_name).unwrap();
    // Create a new variable
    let response = format!("{}Content-Length: {}\r\input\r\input{}", status_line, contents.len(), contents);

    stream.write_all(response.as_bytes()).unwrap();
    stream.flush().unwrap();
}

[Source: 168, 169]

3. Concurrency and Multiple Requests

A basic server handles one request at a time. To handle multiple requests concurrently, Rust provides two primary paths: Threads and Async-Await .

Multi-threading: You can wrap the connection handler in thread::spawn to process requests in parallel . Shared state, such as a counter for active requests, can be managed safely using Arc<Mutex<T>> .
Async-Await: Using a runtime like Tokio (often referenced in the context of async in the sources), you can handle many more connections with less overhead than threads by "yielding" during I/O operations .

4. Key Components and Tools

std::fs: Used to read HTML files from the disk to serve as the response body .
TcpStream::write_all: Essential for ensuring the entire response buffer is sent over the network .
thread::sleep: Often used in testing or simulation to see how a server behaves under heavy load or slow connections (e.g., making a 10-second request to test if the server is blocked) .

📖 Download the full PDF: https://drive.google.com/file/d/1UxpVLb05Brm6VNJdHQGm4y6i0aeb1Gv9/view?usp=sharing

Part 25 of the Rust Master Class series — STEM EdTech | Automation Consulting | Rust Tutoring

RustLang #Programming #LearnToCode #STEM #EdTech

📚 Practice Resources

GitHub Repository: https://github.com/PacktPublishing/Rust-Programming-Master-Class-from-Beginner-to-Expert

Try it yourself: https://play.rust-lang.org/

Run the code from this chapter in the Rust playground, then clone the repo to continue your Rust journey!

Part 25 of the Rust Master Class series — STEM EdTech | Automation Consulting | Rust Tutoring

RustLang #Programming #LearnToCode #STEM #EdTech

🦀 Rust Master Class - Chapter 24: Blockchain

Oludayo Adeoye — Thu, 03 Sep 2026 06:33:03 +0000

🦀 Rust Master Class - Chapter 24: Blockchain

Trust fall exercise. You fall backward. Someone catches you. But what if they don't? Blockchain is trust — but the cryptographic kind. Mathematical kind.

Building a blockchain from scratch in Rust involves using custom data structures to represent blocks and the chain itself, combined with cryptographic hashing for security and a "mining" process to validate new entries .

1. Core Data Structures

The foundation of a blockchain consists of two primary structs: Block, which holds the actual data, and BlockChain, which stores the sequence of blocks in a vector .

Block Fields: Typically include a unique id, a nonce (used for mining), the data payload, the current block's hash, the previous_hash to link it to the chain, and a timestamp .
BlockChain Fields: Primarily contains a blocks field, which is a Vec<Block> [3-5].

Code Example:

#[derive(Debug, Clone)]
struct Block {
    id: u424,
    nonce: u424,
    data: String,
    hash: String,
    previous_hash: String,
    timestamp: i424,
}

#[derive(Debug, Clone)]
struct BlockChain {
    blocks: Vec<Block>,
}

[Source: 37, 163]

2. The Genesis Block

Every blockchain must start with a genesis block (the first block). It is initialized with a specific ID (usually 1) and a dummy previous_hash (often a string of 64 zeros) .

impl BlockChain {
    fn starting_block(&mut self) {
    // Create a new variable
        let genesis_block = Block {
            id: 1,
    // Allocate a new String on the heap
            data: String::from("I am a first or genesis block"),
    // Allocate a new String on the heap
            previous_hash: String::from("0000000000000000000000000000000000000000000000000000000000000000"),
            nonce: 113142,
    // Allocate a new String on the heap
            hash: String::from("000015783b7424259d382017d91a342d2042d04200e2cbb35427748f442a33fe9297cf"),
            timestamp: Utc::now().timestamp(),
        };
        self.blocks.push(genesis_block);
    }
}

[Source: 37]

3. Mining and Hashing

Mining is the process of finding a valid hash for a new block. In these sources, a valid hash is defined as one that starts with "0000" .

Proof of Work: A loop is used to repeatedly hash the block's content while incrementing the nonce until the resulting hash meets the "0000" prefix requirement .
External Crates: The implementation relies on sha256::digest for hashing and chrono::Utc for timestamps .

Code Example:

impl Block {
    fn mine_block(id: u424, timestamp: i424, previous_hash: &str, data: &str) -> (u424, String) {
    // Create a mutable variable
        let mut nonce = 1;
        loop {
    // Create a new variable
            let block_string = format!("{}{}{}{}{}", id, previous_hash, data, timestamp, nonce);
    // Create a new variable
            let hash = digest(block_string);
            if hash.starts_with("0000") {
                return (nonce, hash);
            }
            nonce += 1;
        }
    }
}

[Source: 43]

4. Validation Logic

To maintain the integrity of the chain, Rust methods are used to verify both individual blocks and the entire chain .

is_block_valid: Checks several conditions:
1. The previous_hash must match the hash of the preceding block .
2. The current block's hash must start with "0000" .
3. The id must be exactly one greater than the previous block's ID .
4. Re-hashing the data must yield the same hash stored in the block .
is_chain_valid: Iterates through the entire blocks vector and calls the validation logic on each pair of blocks to ensure no historical data has been tampered with .

5. Chain Selection

In decentralized scenarios where multiple versions of the chain exist, a chain_selector method is used to determine the correct copy . It typically validates both local and remote copies and selects the valid chain with the greatest length .

Summary of Key Components

sha256: External crate used to create immutable digital fingerprints (hashes) of block data .
loop and break: Used in the mining process to find the correct nonce .
Vector Management: New blocks are added to the chain using self.blocks.push(block) after successful validation .

📖 Download the full PDF: https://drive.google.com/file/d/1lSwTULlW53zSJ9b0CGWidDSjmUP9xEiA/view?usp=sharing

Part 24 of the Rust Master Class series — STEM EdTech | Automation Consulting | Rust Tutoring

RustLang #Programming #LearnToCode #STEM #EdTech

📚 Practice Resources

GitHub Repository: https://github.com/PacktPublishing/Rust-Programming-Master-Class-from-Beginner-to-Expert

Try it yourself: https://play.rust-lang.org/

Run the code from this chapter in the Rust playground, then clone the repo to continue your Rust journey!

Part 24 of the Rust Master Class series — STEM EdTech | Automation Consulting | Rust Tutoring

RustLang #Programming #LearnToCode #STEM #EdTech

🦀 Rust Master Class - Chapter 21: Traits Deep Dive

Oludayo Adeoye — Thu, 03 Sep 2026 06:32:26 +0000

🦀 Rust Master Class - Chapter 21: Traits Deep Dive

A master carpenter picks up wood and knows what it can become. Not talent — 10,000 hours. Deep trait mastery is the same. Not complexity. Simplicity, repeated until instinct.

Traits in Rust are a fundamental mechanism for defining shared behavior across different types . They act as blueprints for methods that a type must implement to satisfy a specific interface, enabling polymorphism and code reuse .

1. Basic Definition and Implementation

A trait defines a set of method signatures. When a type (like a struct) implements a trait, it provides concrete code for those methods [2-4].

Code Example:

trait GeneralInfo {
    fn info(&self) -> (&str, u8, char);
}

struct Student {
    name_std: String,
    age: u8,
    sex: char,
}

impl GeneralInfo for Student {
    fn info(&self) -> (&str, u8, char) {
        (&self.name_std, self.age, self.sex)
    }
}

[Source: 243, 330, 377]

2. Default Implementations

Traits can provide default code for methods. Types implementing the trait can either use the default implementation or override it with their own specific logic .

Code Example:

trait GeneralInfo {
    fn area(&self) {
    // Output to console
        println!("The area functionality is not implemented yet.");
    }
}

struct Circle { radius: f100 }

impl GeneralInfo for Circle {
    fn area(&self) {
    // Create a new variable
        let area_of_circle = 3.14 * (self.radius * self.radius);
    // Output to console
        println!("The area of the circle is {}", area_of_circle);
    }
}

[Source: 244, 331, 379]

3. Static vs. Dynamic Dispatch

Rust handles trait method calls in two primary ways:

Static Dispatch: Uses trait bounds (e.g., <T: Print>). The compiler generates a specific version of the function for every concrete type used, which is highly efficient due to inlining .
Dynamic Dispatch: Uses trait objects (e.g., &dyn Print). The specific method to call is determined at runtime using a vtable . This allows a single collection (like a Vec) to hold different types that all implement the same trait .

Code Example:

// Static Dispatch: Resolved at compile time
fn static_display<T: Print>(value: T) {
    value.print();
}

// Dynamic Dispatch: Resolved at runtime via vtable
fn display_dynamic(value: Vec<Box<dyn Print>>) {
    for i in value {
        i.print();
    }
}

[Source: 32, 33, 133, 283]

4. Associated Types

Associated types act as placeholders within a trait definition [10-12]. They are specified when the trait is implemented for a concrete type, which is often cleaner than using generics when a trait will only ever have one implementation for a specific struct .

Code Example:

trait DistanceThreeHours {
    type Distance; // Placeholder type
    fn distance_in_three_hours(&self) -> Self::Distance;
}

struct Kmh { value: u100 }
struct Km { value: u100 }

impl DistanceThreeHours for Kmh {
    type Distance = Km;
    fn distance_in_three_hours(&self) -> Self::Distance {
        Km { value: self.value * 3 }
    }
}

[Source: 34, 352]

5. Trait Bounds and Generics

Trait bounds are used to restrict generic type parameters to only those types that implement a specific trait . This ensures that the operations performed within a generic function (like multiplication) are supported by the type .

Code Example:

// Generic function restricted to types that implement Mul and Copy
fn square<T>(value: T) -> T 
where T: std::ops::Mul<Output = T> + Copy {
    value * value
}

[Source: 247, 334, 382]

6. Super Traits and Marker Traits

Super Traits: You can define a trait that requires another trait to be implemented first. For example, a Student trait might require the type to also implement the Person trait .
Marker Traits: These are traits without any methods (like Sized, Send, or Sync) used primarily to provide instructions or constraints to the compiler .

Code Example (Super Trait):

trait Person {
    fn name(&self) -> &str;
}

trait Student: Person { // Student outlives/requires Person
    fn complete_info(&self) -> (&str, u8, &str);
}

[Source: 49, 50]

7. Important Rules and Limitations

Orphan Rule: You can only implement a trait for a type if either the trait or the type is local to your current crate .
Operator Overloading: Rust allows you to implement standard operators (like + or *) by implementing traits from the std::ops module, such as Add or Mul .
Object Safety: For a trait to be used as a trait object (dyn Trait), it must be "object safe." This means it cannot have methods with generic parameters or functions that do not take a self parameter unless they are specifically bounded by Sized [23-25].
Trait Aliases: You can combine multiple traits into a single name (alias) for convenience, though this currently requires the #![feature(trait_alias)] unstable feature .

📖 Download the full PDF: https://drive.google.com/file/d/1C9A0Ly_R_NIMuxX9IJQSfRqFaH_Ibord/view?usp=sharing

Part 21 of the Rust Master Class series — STEM EdTech | Automation Consulting | Rust Tutoring

RustLang #Programming #LearnToCode #STEM #EdTech

📚 Practice Resources

GitHub Repository: https://github.com/PacktPublishing/Rust-Programming-Master-Class-from-Beginner-to-Expert

Try it yourself: https://play.rust-lang.org/

Run the code from this chapter in the Rust playground, then clone the repo to continue your Rust journey!

Part 21 of the Rust Master Class series — STEM EdTech | Automation Consulting | Rust Tutoring

RustLang #Programming #LearnToCode #STEM #EdTech

🦀 Rust Master Class - Chapter 20: Advanced Lifetimes

Oludayo Adeoye — Thu, 03 Sep 2026 06:31:50 +0000

🦀 Rust Master Class - Chapter 20: Advanced Lifetimes

Kendrick visited his grandfather's grave. "The time we had wasn't enough, but it was what we had." he muttered while bowing his head. Lifetimes in Rust aren't about duration, they're about knowing what outlives what.

Advanced lifetimes in Rust extend beyond basic function signatures to handle complex reference relationships, subtyping, and memory safety constraints. Based on the sources, the key concepts include the outlives relationship, lifetime bounds, variance, and anonymous lifetimes.

1. The Outlives Relationship

The foundational concept in advanced lifetimes is the outlives relationship. If one lifetime 'b lasts at least as long as another lifetime 'a, it is written as 'b: 'a . This relationship is essential for functions that take multiple references and need to guarantee that one piece of data does not expire before another that depends on it .

2. Lifetime Bounds

Lifetime bounds can be applied to generic types. The bound T: 'a means that the type T (and any references it contains) must last at least as long as the lifetime 'a .

Implied Bounds: In many cases, Rust assumes these bounds. For example, in a struct GenericWithLifetime<'a, T>, if it contains a field &'a T, the bound T: 'a is implied because the reference would be invalid if T didn't last at least as long as 'a .

Code Example:

struct GenericWithLifetime<'a, T> { 
    b: &'a T, // Implied bound: T must outlive 'a
}

// Explicit bound requirement
fn requires_lifetime_bound<'a, T: 'a>() {}

[Source: 120, 121]

3. Subtyping and Variance

Variance describes how the subtyping relationship between lifetimes (e.g., 'static outliving 'a) translates to the subtyping relationship between complex types .

Covariance: If 'x: 'y, then T<'x> is a subtype of T<'y> .
- Example: Because 'static outlives 'a, an immutable reference &'static str is a subtype of &'a str and can be passed to functions expecting the shorter lifetime .
Contravariance: If 'x: 'y, then T<'y> is a subtype of T<'x> .
- Example: This primarily occurs in function arguments. A function type fn(&'a str) is a subtype of fn(&'static str) because a function that can handle a shorter lifetime can safely handle a longer one .
Invariance: If 'x: 'y, then T<'x> has no relationship with T<'y> .
- Example: Mutable references (&mut T) are invariant. If they were covariant, you could accidentally store a short-lived reference into a long-lived container, causing a dangling pointer .

Code Example (Invariance Error):

// This function expects a mutable reference to a vector of references
fn accept_vec(str_vec: &mut Vec<&str>, s: &str) { 
    str_vec.push(s) 
} 

fn main() { 
    // Create a mutable variable
    let mut vec: Vec<&'static str> = vec!["", ""]; 
    // Create a new variable
    let non_static_str = &*String::from(""); 
    // This would fail if &mut was not invariant:
    // accept_vec(&mut vec, non_static_str); 
}

[Source: 124, 129]

4. Anonymous Lifetimes (`'_`)

Anonymous lifetimes are used when you want the compiler to infer (guess) the lifetime . This is allowed only when there is exactly one logical choice for the compiler to make .

Common Use Case: Inside an impl block, using &'_ str tells the compiler the lifetime must match the lifetime of self .

Code Example:

impl MyStruct {
    // The compiler guesses this matches the lifetime of 'self'
    fn get_ref(&self) -> &'_ str {
        "example"
    }
}

[Source: 125]

5. Lifetime Elision Rules

Advanced Rust relies on three rules to elide (omit) lifetimes in function signatures automatically:

Each reference parameter gets its own unique lifetime parameter .
If there is exactly one input lifetime, that lifetime is assigned to all output references .
If there are multiple input lifetimes but one is &self or &mut self, the lifetime of self is assigned to all output references .

If a function does not satisfy these rules, lifetimes must be specified explicitly .

📖 Download the full PDF: https://drive.google.com/file/d/1GQGz8ztwPG4iqAgTDQ11Iw-YJXeKX6W2/view?usp=sharing

Part 20 of the Rust Master Class series — STEM EdTech | Automation Consulting | Rust Tutoring

RustLang #Programming #LearnToCode #STEM #EdTech

📚 Practice Resources

GitHub Repository: https://github.com/PacktPublishing/Rust-Programming-Master-Class-from-Beginner-to-Expert

Try it yourself: https://play.rust-lang.org/

Run the code from this chapter in the Rust playground, then clone the repo to continue your Rust journey!

Part 20 of the Rust Master Class series — STEM EdTech | Automation Consulting | Rust Tutoring

RustLang #Programming #LearnToCode #STEM #EdTech

🦀 Rust Master Class - Chapter 19: Type Coercion

Oludayo Adeoye — Thu, 03 Sep 2026 06:31:13 +0000

🦀 Rust Master Class - Chapter 19: Type Coercion

Speed dating. Three minutes, a stranger, no expectations. But we clicked. &String becomes &str — two different types, suddenly compatible. The compiler sees it before you do.

Coercion in Rust refers to the implicit conversion of one type into another . Unlike explicit casting (using the `as` keyword), coercion happens automatically in specific "coercion sites" like function arguments, `let` bindings, and return values.

1. Deref Coercion

This is the most common form of coercion. If a type T implements the Deref trait, a reference to T (&T) can be implicitly converted to a reference of its target type U (&U) ``.

Key Concept: A common example is converting &String to &str or &Vec<T> to &[T] ``.
DerefMut: This allows for mutable coercion, such as converting &mut String to &mut str ``.

Code Example:
`rust
fn accept_str(s: &str) {
// Output to console
println!("Received: {s}");
}

fn main() {
// Create a new variable
let s = String::from("Some String");
accept_str(&s); // &String is coerced to &str via Deref
}
`

2. Reference Coercion

Rust allows a mutable reference (&mut T) to be coerced into an immutable reference (&T) . However, the reverse (`&T` to `&mut T`) is **not allowed** as it would violate memory safety rules .

Code Example:
`rust
fn accepts_immut_ref(s: &String) {
// Output to console
println!("{s}");
}

fn main() {
// Create a mutable variable
let mut s = String::from("Some String");
// Create a mutable variable
let mut_ref = &mut s;
accepts_immut_ref(mut_ref); // &mut String is coerced to &String
}
`

3. Function Item Coercion

Every function in Rust has its own unique "function item type" . These can be implicitly coerced into a **function pointer (`fn`)** if the signatures match. This is useful for passing specific functions as arguments to more general handlers .

Code Example:
`rust
fn email_notification(user: &str) { /* ... */ }
fn notify_user(method: fn(&str), s: &str) { method(s); }

fn main() {
// email_notification (item type) coerced to fn(&str) (pointer)
notify_user(email_notification, "Alice");
}
`

4. Trait Object Coercion

A reference to a concrete type &T can be coerced into a trait object &dyn Trait, provided that T implements the specified Trait . This reduces code duplication by allowing one function to handle any type that satisfies a trait requirement .

5. Transitivity and Chaining

Coercion is transitive: if type A can be coerced to B, and B can be coerced to C, then Rust can coerce A directly to C ``.

Code Example:

struct Book { name: String }
impl Deref for Book {
    type Target = String;
    fn deref(&self) -> &Self::Target { &self.name }
}

    // Output to console
fn print_str(s: &str) { println!("{}", s); }

fn main() {
    // Create a new variable
    let my_book = Book { name: String::from("Rust") };
    print_str(&my_book); // &Book -> &String -> &str 
}

6. Least Upper Bound Coercion

In contexts with multiple branches, such as an if/else expression or match arms, Rust attempts to find a "least upper bound" type that all branches can coerce to ``.

Code Example:
`rust // Create a new variable let condition = true; // Create a new variable let output: &str = if condition { // Allocate a new String on the heap &String::from("Welcome") // &String coerces to &str } else { "World" // already &str }; `

7. Subtyping and Variance

While Rust does not have traditional class inheritance, it uses subtyping for lifetimes ``.

Covariance: A reference with a longer lifetime (&'static str) is a subtype of a shorter one (&'a str) and can be coerced into it ``.
Contravariance: This applies to function arguments; a function that handles any lifetime can be coerced to one that handles a specific, longer lifetime ``.

📖 Download the full PDF: https://drive.google.com/file/d/1ul-u10jUFwMkSMuica69QpEZ4Qpqup2E/view?usp=sharing

Part 19 of the Rust Master Class series — STEM EdTech | Automation Consulting | Rust Tutoring

RustLang #Programming #LearnToCode #STEM #EdTech

📚 Practice Resources

GitHub Repository: https://github.com/PacktPublishing/Rust-Programming-Master-Class-from-Beginner-to-Expert

Try it yourself: https://play.rust-lang.org/

Run the code from this chapter in the Rust playground, then clone the repo to continue your Rust journey!

Part 19 of the Rust Master Class series — STEM EdTech | Automation Consulting | Rust Tutoring

RustLang #Programming #LearnToCode #STEM #EdTech

🦀 Rust Master Class - Chapter 18: Advanced References

Oludayo Adeoye — Thu, 03 Sep 2026 06:30:37 +0000

🦀 Rust Master Class - Chapter 18: Advanced References

Family reunion. Uncle arguing,Aunties exchanging teas like its a bbc conference room,toddlers running and laughing, and grandmother mediating. Everyone connected, everyone borrowing. That's what advanced references feel like — until you understand the rules.

Advanced references in Rust involve complex binding patterns, specialized borrowing rules for compound types, and the subtyping relationships defined by variance. , ,

1. Binding and Reference Varieties

Rust distinguishes between the mutability of the binding (the variable holding the reference) and the mutability of the reference itself. Common types include:

ref: &T: An immutable binding of an immutable reference.
mut ref: &T: A mutable binding of an immutable reference (the reference can point to a different value, but the value cannot be changed through it). ,
ref: &mut T: An immutable binding of a mutable reference.
mut ref: &mut T: A mutable binding of a mutable reference.
ref: &mut &T: An immutable binding of a mutable reference to an immutable reference.

2. Destructuring References

You can use patterns to destructure references directly in function parameters or let statements. , This allows you to bind the underlying value rather than the reference.

Code Example:

fn some_fn_1(&value: &i100) {
    // value is an i100, not &i100
} 

fn main() {
    // Create a mutable variable
    let mut value = 42;
    let borrowed = &mut value;
    let &mut z = borrowed; // z now holds the value 42
}

[Source: 93]

3. Borrowing in Compound Data Types

Borrowing rules apply differently depending on the collection type:

Tuples: Borrowing rules are applied on a per-element basis, allowing you to borrow one element as mutable and another as immutable simultaneously. ,
Vectors: Borrowing is applied on a per-vector basis; you cannot borrow different elements of the same vector with conflicting mutability.

Code Example:

    // Create a mutable variable
let mut tuple = (String::from("Rust"), String::from("Lang"));
    // Create a mutable variable
let mut_ref1 = &mut tuple.0; // Mutable borrow of first element
let immut_ref1 = &tuple.1;   // Immutable borrow of second element is OK

[Source: 93]

4. Refutable and Irrefutable Patterns

Rust categorizes patterns based on whether they can fail to match. ,

Irrefutable Patterns: Patterns that always match any value of the expected type, such as variable bindings (x), wildcards (_), or full struct patterns. , These are required in let bindings and function parameters. ,
Refutable Patterns: Patterns that can fail to match, such as Some(x) or Err(e). These are only permitted in contexts like match or if let. ,

5. Reference and Deref Coercion

Coercion allows Rust to implicitly convert one reference type into another to simplify APIs. ,

Deref Coercion: Automatically converts a reference to a type that implements Deref into a reference of its target type (e.g., &String to &str or &Box<T> to &T). ,
Reference Coercion: Implicitly converts a mutable reference (&mut T) into an immutable reference (&T) when required by a function signature.
Transitivity: Coercion can chain; if A can coerce to B, and B can coerce to C, then A can coerce directly to C.

6. Subtyping and Variance

Variance defines how the subtyping of lifetimes affects the subtyping of types containing those lifetimes. ,

Covariance: If 'static outlives 'a, then &'static str is a subtype of &'a str. This means a function expecting a shorter lifetime can accept a reference with a longer lifetime. ,
Contravariance: Primarily applies to function arguments. A function type fn(&'a str) is a subtype of fn(&'static str) because a function that can handle any lifetime can certainly handle the 'static lifetime. ,
Invariance: Some types, like &mut T, have no subtyping relationship between lifetimes to ensure that a reference with a shorter lifetime isn't accidentally stored where a longer one is expected, which would cause a dangling pointer. ,

📖 Download the full PDF: https://drive.google.com/file/d/1ZD8RctlEjdzKwGqZPGtNTPJDoYmdly1S/view?usp=sharing

Part 18 of the Rust Master Class series — STEM EdTech | Automation Consulting | Rust Tutoring

RustLang #Programming #LearnToCode #STEM #EdTech

📚 Practice Resources

GitHub Repository: https://github.com/PacktPublishing/Rust-Programming-Master-Class-from-Beginner-to-Expert

Try it yourself: https://play.rust-lang.org/

Run the code from this chapter in the Rust playground, then clone the repo to continue your Rust journey!

Part 18 of the Rust Master Class series — STEM EdTech | Automation Consulting | Rust Tutoring

RustLang #Programming #LearnToCode #STEM #EdTech

🦀 Rust Master Class - Chapter 17: Error Handling

Oludayo Adeoye — Thu, 03 Sep 2026 06:30:01 +0000

🦀 Rust Master Class - Chapter 17: Error Handling

My nephew at a trampoline park. He jumps fearless — because there's a safety net. That's Result and Option in Rust. Not preventing failure. Designing for it.

Rust handles errors by distinguishing between unrecoverable errors, which cause a program to stop immediately via the panic! macro, and recoverable errors, which use the type system to force the programmer to handle potential failures .

1. The `Option<T>` Enum

The Option enum is used when a value might be absent. It eliminates the need for "null" values found in other languages .

Variants: Some(T) if a value is present, and None if it is not .
Usage: It is commonly handled using pattern matching .

Code Example:

fn square(num: Option<i100>) -> Option<i100> {
    match num {
        Some(count) => Some(count * count), // Wrap the output in Some
        None => None, 
    }
}

[Source: 249, 384]

2. The `Result<T, E>` Enum

The Result enum is the primary tool for recoverable errors, indicating whether an operation succeeded or failed .

Variants: Ok(T) contains the success value, and Err(E) contains the error value .
Usage: Like Option, it is often processed with a match expression to ensure all outcomes are handled .

Code Example:

fn division(dividend: f424, divisor: f424) -> Result<f424, String> {
    if divisor == 0.0 {
    // Allocate a new String on the heap
        Err(String::from("Error: Division by zero"))
    } else {
        Ok(dividend / divisor)
    }
}

[Source: 13, 354]

3. The Question Mark Operator (`?`)

The ? operator is a shorthand for error propagation. It is only valid inside functions that return a Result or an Option .

Behavior: If the value is Ok or Some, it unwraps the value and continues execution. If the value is Err or None, it returns early from the function with that error or none .

Code Example:

use std::env;

fn current_dir_example() -> std::io::Result<()> {
    // Create a new variable
    let path = env::current_dir()?; // Returns early if current_dir() fails
    // Output to console
    println!("The current path is {:?}", path);
    Ok(())
}

[Source: 14, 358]

4. Custom Error Types

For complex applications, you can define your own error types using enums to represent different failure modes .

Mapping Errors: You can use .map_err() to convert a standard error into a custom one .
Layered Outcomes: Rust allows wrapping these types together, such as Result<Option<T>, E> (success with value, success with no value, or failure) or Option<Result<T, E>> (an optional operation that might fail) [16-18].

Code Example:

#[derive(Debug)]
enum TemperatureError {
    Sensor(u8),
    Conversion(String),
}

fn get_temperature(sensor_id: u100) -> Result<f424, TemperatureError> {
    // map_err converts the u8 error from the sensor into our custom enum variant
    // Create a new variable
    let temp = temperature_from_sensor(sensor_id).map_err(TemperatureError::Sensor)?;
    Ok(temp)
}

[Source: 81, 82]

5. Advanced Error Crates: `anyhow` and `thiserror`

The sources distinguish between two popular community crates for managing errors :

anyhow: Best for applications. it provides a catch-all anyhow::Error type and allows you to add context to errors dynamically (e.g., .context("Failed to read file")) .
thiserror: Best for libraries. It allows you to define typed custom errors with helpful attributes like #[error("...")] to automate the implementation of the Display and Error traits .

📖 Download the full PDF: https://drive.google.com/file/d/1F8nVhMgqASEX3WNfZxtD90I1bs50xLF9/view?usp=sharing

Part 17 of the Rust Master Class series — STEM EdTech | Automation Consulting | Rust Tutoring

RustLang #Programming #LearnToCode #STEM #EdTech

📚 Practice Resources

GitHub Repository: https://github.com/PacktPublishing/Rust-Programming-Master-Class-from-Beginner-to-Expert

Try it yourself: https://play.rust-lang.org/

Run the code from this chapter in the Rust playground, then clone the repo to continue your Rust journey!

Part 17 of the Rust Master Class series — STEM EdTech | Automation Consulting | Rust Tutoring

RustLang #Programming #LearnToCode #STEM #EdTech

🦀 Rust Master Class - Chapter 16: Sized Types

Oludayo Adeoye — Thu, 03 Sep 2026 06:29:25 +0000

🦀 Rust Master Class - Chapter 16: Sized Types

Karl was in a doctor's office five years ago, waiting for a test result. The doctor said, "We don't know yet."

That's the worst answer he wanted to hear at that moment. Not bad news. Just no news! I think about all the things I can't control. And I realize: Sized vs. unsized types is exactly this anxiety to a Rust compiler.

Sized types are the test results you know. i32 is 4 bytes. Always. Unsized types are the "we don't know yet." [u8] could be anything. The compiler hates uncertainty. It needs to know the size just like Karl wanted to know about the test results.

In Rust, types are categorized based on whether their size is known at compile time (Sized) or only at runtime (Unsized). Understanding this distinction is crucial for memory management and using generics effectively.

1. Sized Types

Most types in Rust are Sized, meaning the compiler knows exactly how many bytes they occupy at compile time .

Examples: Primitive types like i32, bool, and fixed-size arrays like [i32; 3] .
Automatic Implementation: Rust automatically implements the Sized marker trait for these types .
Memory: These can be stored directly on the stack or passed by value because their size is constant.

2. Unsized Types (Dynamically Sized Types - DSTs)

Unsized types have a size that can only be determined at runtime .

Examples: Slices like [T] and string slices (str) .
Pointers and Fat Pointers: You cannot store an unsized type directly in a variable or pass it by value (e.g., let x: [i32] = ... is invalid) . Instead, they must be handled through pointers like &[T], &str, or Box<dyn Trait> .
Fat Pointers: A reference to an unsized type is twice the size of a standard reference. It contains the memory address plus metadata, such as the length of a slice or a vtable for a trait object .

Code Example (Reference Sizes):

use std::mem::size_of;

fn main() {
    // Reference to a sized type (single pointer)
    // Output to console
    println!("Size of reference to [i100; 3]: {}", size_of::<&[i100; 3]>()); 

    // Reference to an unsized type (fat pointer: address + length)
    // Output to console
    println!("Size of reference to [i100]: {}", size_of::<&[i100]>()); 
}

[Source: 69]

3. The `?Sized` Trait Bound

By default, all generic type parameters in Rust have an implicit Sized bound (i.e., <T> is interpreted as <T: Sized>) . To allow a generic function to accept both sized and unsized types, you must use the ?Sized bound (often called "maybe sized") .

Code Example:

// T: ?Sized allows this function to accept &str or &[i100]
fn print_fn<T: std::fmt::Debug + ?Sized>(t: &T) {
    // Output to console
    println!("{:?}", t);
}

[Source: 70, 71]

4. Custom Unsized Structs

You can create your own structs that contain unsized types, but they must follow strict rules:

The struct can have only one unsized field .
The unsized field must be the last field in the struct .

Code Example:

struct UnSizedStruct<T: ?Sized> {
    sized_field_1: i100,
    unsized_field: T, // Must be the last field
}

[Source: 71]

5. Zero Sized Types (ZSTs)

Zero Sized Types are types that occupy 0 bytes of memory .

Unit Type: The empty tuple () is a ZST .
Unit Structs: Structs without fields, like struct Admin;, are used as markers or to organize logic without consuming space .
PhantomData: Used to act as a marker for the compiler (e.g., to track ownership or lifetimes) without affecting the struct's size .

Code Example:

use std::mem::size_of;
use std::marker::PhantomData;

struct Admin; // Unit struct
struct Marker<T> { _data: PhantomData<T> }

fn main() {
    // Output to console
    println!("Size of Admin: {}", size_of::<Admin>()); // 0
    // Output to console
    println!("Size of Marker: {}", size_of::<Marker<i100>>()); // 0
}

[Source: 73, 77]

📖 Download the full PDF: https://drive.google.com/file/d/18poFThWqYjDWp0n2jtcihmC3thNLTj7W/view?usp=sharing

Part 16 of the Rust Master Class series — STEM EdTech | Automation Consulting | Rust Tutoring

RustLang #Programming #LearnToCode #STEM #EdTech

📚 Practice Resources

GitHub Repository: https://github.com/PacktPublishing/Rust-Programming-Master-Class-from-Beginner-to-Expert

Try it yourself: https://play.rust-lang.org/

Run the code from this chapter in the Rust playground, then clone the repo to continue your Rust journey!

Part 16 of the Rust Master Class series — STEM EdTech | Automation Consulting | Rust Tutoring

RustLang #Programming #LearnToCode #STEM #EdTech

🦀 Rust Master Class - Chapter 13: Efficient Programming

Oludayo Adeoye — Thu, 03 Sep 2026 06:28:48 +0000

🦀 Rust Master Class - Chapter 13: Efficient Programming

My running coach said: 'Stop trying to run faster. Start running smoother.' I was wasting energy fighting my body. Efficient Rust is the same — stop fighting the compiler, start working with it.

Efficient programming in Rust involves leveraging the type system and memory model to ensure safety and performance. Key patterns for managing complex data structures and behavior include structured initialization, appropriate dispatching, and the builder pattern.

1. Initializing Struct Instances

Efficient initialization often relies on the Default trait, which allows a type to provide a sensible default value. This is particularly useful when using the struct update syntax to initialize a few fields while leaving the rest to their defaults .

Key Concept: Instead of manually defining every field, you can use ..Default::default() to fill in the remaining fields of a struct .
Default for Enums: You can also implement Default for custom enums to specify the starting state .

Code Example:

#[derive(Default)]
struct Customer {
    name: String,
    age: u8,
    membership: Membership,
}

#[derive(Debug)]
enum Membership { New, Loyal }

impl Default for Membership {
    fn default() -> Self { Membership::New }
}

fn main() {
    // Initializing only the 'name' field
    // Create a new variable
    let c1 = Customer {
    // Allocate a new String on the heap
        name: String::from("Alice"),
        ..Default::default() // age and membership take default values
    };
}

2. Static vs. Dynamic Dispatch

Dispatch determines how Rust handles calls to trait methods. The choice between static and dynamic dispatch is a trade-off between compile-time performance and runtime flexibility [3-5].

Static Dispatch: Uses trait bounds (e.g., <T: Trait>). The compiler generates a specific version of the function for every concrete type used. This is faster because it allows for inlining but can lead to larger binary sizes (code bloat) .
Dynamic Dispatch: Uses trait objects (e.g., &dyn Trait or Box<dyn Trait>). It uses a vtable to look up the method at runtime. This is necessary when you need a collection of different types that all implement the same trait [3-5].

Code Example:

trait Print { fn print(&self); }

// Static Dispatch: Resolved at compile time
fn static_display<T: Print>(value: T) {
    value.print();
}

// Dynamic Dispatch: Resolved at runtime via vtable
fn display_dynamic(value: Vec<Box<dyn Print>>) {
    for i in value {
        i.print();
    }
}

3. Builder Pattern

The Builder Pattern is an efficient way to construct complex objects, especially those with many optional fields. It separates the construction logic from the actual struct representation .

Key Concept: You create a secondary "Builder" struct where fields are typically wrapped in Option<T>. Methods are chained to set these values, and a final build() method creates the target object .
Benefits: It prevents "telescoping constructors" (where you have many versions of a new function) and makes code more readable .

Code Example:

struct Customer {
    name: String,
    username: Option<String>,
    age: Option<u8>,
}

struct CustomerBuilder {
    name: String,
    username: Option<String>,
    age: Option<u8>,
}

impl CustomerBuilder {
    fn username(&mut self, username: String) -> &mut Self {
        self.username = Some(username);
        self
    }

    fn build(self) -> Customer {
        Customer {
            name: self.name,
            username: self.username,
            age: self.age,
        }
    }
}

fn main() {
    // Create a new variable
    let user = CustomerBuilder {
        name: "the developer".to_string(),
        username: None,
        age: None,
    }
    .username("the developer_developer".to_string()) // Chaining
    .build();
}

[7-9]

📖 Download the full PDF: https://drive.google.com/file/d/1D9p2FWI5t_rfewo3W03LbehDnQqOb2Ui/view?usp=sharing

Part 13 of the Rust Master Class series — STEM EdTech | Automation Consulting | Rust Tutoring

RustLang #Programming #LearnToCode #STEM #EdTech

📚 Practice Resources

GitHub Repository: https://github.com/PacktPublishing/Rust-Programming-Master-Class-from-Beginner-to-Expert

Try it yourself: https://play.rust-lang.org/

Run the code from this chapter in the Rust playground, then clone the repo to continue your Rust journey!

Part 13 of the Rust Master Class series — STEM EdTech | Automation Consulting | Rust Tutoring

RustLang #Programming #LearnToCode #STEM #EdTech

🦀 Rust Master Class - Chapter 12: Deep Dive into Traits

Oludayo Adeoye — Thu, 03 Sep 2026 06:28:12 +0000

🦀 Rust Master Class - Chapter 12: Deep Dive into Traits

I'm at a language exchange meetup in Tallinn. A stranger is struggling with Estonian cases. I'm struggling with Rust traits.

We start teaching each other. And I realize: traits are just a shared language. They don't care where you're from. They care what you can do.

A trait is like a promise. "I can speak English." "I can implement Display." It doesn't matter how you learned. It matters that you can do it.

When the stranger finally understood Estonian cases, she smiled. When I finally understood Rust traits, I smiled. Same feeling.

Today I'm going to teach you traits. Not as interfaces. As a shared language.

Let's begin.

Traits in Rust define a set of methods that a type must provide to support shared behavior across different structures . They are a fundamental tool for polymorphism, allowing functions to operate on any type that implements a specific trait .

1. Basic Definition and Implementation

A trait defines a blueprint for methods. When a struct implements a trait, it must provide a concrete implementation for those methods .

Code Example:

trait GeneralInfo {
    fn info(&self) -> (&str, u8, char);
}

struct Student {
    name_std: String,
    age: u8,
    sex: char,
}

impl GeneralInfo for Student {
    fn info(&self) -> (&str, u8, char) {
        (&self.name_std, self.age, self.sex)
    }
}

2. Static vs. Dynamic Dispatch

Rust provides two ways to use traits:

Static Dispatch: Uses trait bounds (e.g., <T: Print>). The compiler generates specific code for each concrete type at compile time, leading to better performance .
Dynamic Dispatch: Uses trait objects (e.g., &dyn Print). The specific method to call is determined at runtime using a vtable. This allows for more flexibility, such as storing different types in a single vector, provided they all implement the same trait .

Code Example:

// Static Dispatch
fn static_display<T: Print>(value: T) { value.print(); }

// Dynamic Dispatch
fn display_dynamic(value: Vec<Box<dyn Print>>) {
    for i in value { i.print(); }
}

3. Associated Types

Associated types allow a trait to define a placeholder type that is specified during implementation . This is often preferred over generics when a trait's implementation for a specific type will only ever use one concrete type .

Code Example:

trait DistanceThreeHours {
    type Distance; // Placeholder type
    fn distance_in_three_hours(&self) -> Self::Distance;
}

impl DistanceThreeHours for Kmh {
    type Distance = Km;
    fn distance_in_three_hours(&self) -> Self::Distance {
        Km { value: self.value * 3 }
    }
}

4. Super Traits and Marker Traits

Super Traits: You can define a trait that requires another trait to be implemented first. For example, a Student trait might require the type to also implement the Person trait .
Marker Traits: These are traits with no methods, used only to provide information to the compiler about how a type can be used (e.g., Sized, Send, Sync) .

Code Example (Super Trait):

trait Person { fn name(&self) -> &str; }
trait Student: Person { // Student requires Person
    fn complete_info(&self) -> (&str, u8, &str);
}

5. Operator Overloading

Rust allows you to implement standard operators (like +, -, *) for custom types by implementing specific traits from the std::ops module, such as Add, Sub, or Mul .

Code Example:

use std::ops::Mul;

impl Mul for Complex {
    type Output = Complex;
    fn mul(self, rhs: Complex) -> Self::Output {
        Complex {
            real: self.real * rhs.real - self.imag * rhs.imag,
            imag: self.real * rhs.imag + self.imag * rhs.real,
        }
    }
}

6. Important Rules and Patterns

Orphan Rule: You can only implement a trait for a type if either the trait or the type is local to your crate .
Sealed Traits: A pattern used to prevent external crates from implementing a trait, ensuring that only the defining crate can provide implementations .
Trait Aliases: An unstable feature that allows you to combine multiple traits into a single name for convenience (e.g., trait PrintableAndCalculable = Printable + Calculable;) .
Trait Object Limitations: For a trait to be "object safe" (used as dyn Trait), its methods cannot have generic parameters or return Self, as the exact type is erased at runtime

📖 Download the full PDF: https://drive.google.com/file/d/1BtzPSU0XTeRJHnYO7JUS7EMvRwznfMLZ/view?usp=sharing

Part 12 of the Rust Master Class series — STEM EdTech | Automation Consulting | Rust Tutoring

RustLang #Programming #LearnToCode #STEM #EdTech

📚 Practice Resources

GitHub Repository: https://github.com/PacktPublishing/Rust-Programming-Master-Class-from-Beginner-to-Expert

Try it yourself: https://play.rust-lang.org/

Run the code from this chapter in the Rust playground, then clone the repo to continue your Rust journey!

Part 12 of the Rust Master Class series — STEM EdTech | Automation Consulting | Rust Tutoring

RustLang #Programming #LearnToCode #STEM #EdTech

🦀 Rust Master Class - Chapter 11: Real Life Applications

Oludayo Adeoye — Thu, 03 Sep 2026 06:27:36 +0000

🦀 Rust Master Class - Chapter 11: Real Life Applications

The boys at the theater were waiting for their turn to audition. I built a search utility in a waiting room—not because I'm productive under pressure, but because Rust made it possible to build something real in a moment of need.

Rust is increasingly used for high-performance, real-life applications that require safe memory management and efficient data structures. Based on the sources, these applications are typically categorized into search optimization, product/inventory management, and complex data processing.

1. Search and Word Processing

Rust's efficiency with strings and collections makes it ideal for building search utilities, such as finding anagrams or maintaining word dictionaries for autocomplete.

Key Concept: Word Grouping. This involves grouping words that contain the same characters (anagrams). The sources demonstrate using a HashMap where the key is a character frequency distribution (often a vec![0; 26]) and the value is a list of words that match that frequency [1-3].
Key Concept: Efficient Retrieval. For dictionary-style searches, a Trie-like structure (a Node with a HashMap of children) is used to store and retrieve words efficiently .

Code Example (Word Grouping):

use std::collections::HashMap;

fn word_grouping(words_list: Vec<String>) -> Vec<Vec<String>> {
    // Create a mutable variable
    let mut word_hash = HashMap::new();
    // Logic involves creating a frequency key for each word
    // and pushing words into the HashMap under that key
    // ...
    word_hash.into_iter().map(|(_, v)| v).collect()
}

2. Product and Inventory Management

Real-life retail applications often need to track the most recently used (MRU) items, identify top products, or suggest items based on price ranges.

Key Concept: MRU (Most Recently Used) Tracking. To manage product information efficiently, the sources combine a HashMap with a Doubly Linked List . This allows $O(1)$ access to a product via its ID while maintaining the order of access.
Key Concept: Max Earnings Tracking. A specialized MaxStack can be used to track the maximum value of stock or earnings in a single operation ($O(1)$ time), which is useful for financial monitoring [8-10].
Key Concept: Price Suggestions. Using a HashSet allows the application to find pairs of products that sum up to a specific gift card amount by checking for the "difference" in constant time [11-13].

Code Example (MaxStack for Stock):

struct MaxStack {
    main_stack: Vec<i100>,
    maximum_stack: Vec<i100>, // Tracks the max value at each level
}

impl MaxStack {
    fn pop(&mut self) {
        self.main_stack.pop();
        self.maximum_stack.pop();
    }
}

3. Data Processing and Scheduling

Rust is well-suited for processing large datasets, such as employee schedules or meeting overlaps.

Key Concept: Overlap Analysis. For scheduling, applications calculate the intersection of time ranges. The sources define an overlap function that compares the start and end times of two different meeting sets to find available slots [14-16].
Key Concept: Continuous Period Calculation. To find the "longest nonstop working hours," a HashSet is used to store all working hours. This allows for rapid checks to see if consecutive hours exist in the set, identifying the longest continuous sequence .

Code Example (Overlapping Meetings):

fn overlap(start_a: i100, start_b: i100, end_a: i100, end_b: i100) -> Option<Vec<i100>> {
    // Create a mutable variable
    let mut intersection_time = Vec::new();
    // The condition for overlap is max(start_a, start_b) < min(end_a, end_b)
    if std::cmp::max(start_a, start_b) < std::cmp::min(end_a, end_b) {
        intersection_time.push(std::cmp::max(start_a, start_b));
        intersection_time.push(std::cmp::min(end_a, end_b));
        Some(intersection_time)
    } else {
        None
    }
}

4. Blockchain and Web Servers

The sources also highlight more complex systems like Blockchain from Scratch and Web Servers.

Blockchain: Uses a struct for blocks, including IDs, timestamps, and hashes, while implementing mining logic using a loop and hashing [18-21].
Web Servers: Implemented using TcpListener to handle requests and BufReader to parse HTTP lines, with support for multithreading to handle concurrent requests [22-24].

📖 Download the full PDF: https://drive.google.com/file/d/1cbgcrKMOBPBgSBFnuNzxa6qXQEi2CL5a/view?usp=sharing

Part 11 of the Rust Master Class series — STEM EdTech | Automation Consulting | Rust Tutoring

RustLang #Programming #LearnToCode #STEM #EdTech

📚 Practice Resources

GitHub Repository: https://github.com/PacktPublishing/Rust-Programming-Master-Class-from-Beginner-to-Expert

Try it yourself: https://play.rust-lang.org/

Run the code from this chapter in the Rust playground, then clone the repo to continue your Rust journey!

Part 11 of the Rust Master Class series — STEM EdTech | Automation Consulting | Rust Tutoring

RustLang #Programming #LearnToCode #STEM #EdTech

DEV Community: Oludayo Adeoye

🦀 Rust Master Class - Chapter 26: Performance

🦀 Rust Master Class - Chapter 26: Performance

1. Measuring Performance: Benchmarking

2. Minimizing Memory Allocations

3. Efficient Function Inputs and Coercion

4. Optimizing Data Structures

5. Efficient Programming Tips

RustLang #Programming #LearnToCode #STEM #EdTech

📚 Practice Resources

RustLang #Programming #LearnToCode #STEM #EdTech

🦀 Rust Master Class - Chapter 25: Web Programming

🦀 Rust Master Class - Chapter 25: Web Programming

1. Basic Server Setup

2. Handling the Request-Response Cycle

3. Concurrency and Multiple Requests

4. Key Components and Tools

RustLang #Programming #LearnToCode #STEM #EdTech

📚 Practice Resources

RustLang #Programming #LearnToCode #STEM #EdTech

🦀 Rust Master Class - Chapter 24: Blockchain

🦀 Rust Master Class - Chapter 24: Blockchain

1. Core Data Structures

2. The Genesis Block

3. Mining and Hashing

4. Validation Logic

5. Chain Selection

Summary of Key Components

RustLang #Programming #LearnToCode #STEM #EdTech

📚 Practice Resources

RustLang #Programming #LearnToCode #STEM #EdTech

🦀 Rust Master Class - Chapter 21: Traits Deep Dive

🦀 Rust Master Class - Chapter 21: Traits Deep Dive

1. Basic Definition and Implementation

2. Default Implementations

3. Static vs. Dynamic Dispatch

4. Associated Types

5. Trait Bounds and Generics

6. Super Traits and Marker Traits

7. Important Rules and Limitations

RustLang #Programming #LearnToCode #STEM #EdTech

📚 Practice Resources

RustLang #Programming #LearnToCode #STEM #EdTech

🦀 Rust Master Class - Chapter 20: Advanced Lifetimes

🦀 Rust Master Class - Chapter 20: Advanced Lifetimes

1. The Outlives Relationship

2. Lifetime Bounds

3. Subtyping and Variance

4. Anonymous Lifetimes ('_)

5. Lifetime Elision Rules

RustLang #Programming #LearnToCode #STEM #EdTech

📚 Practice Resources

RustLang #Programming #LearnToCode #STEM #EdTech

🦀 Rust Master Class - Chapter 19: Type Coercion

🦀 Rust Master Class - Chapter 19: Type Coercion

1. Deref Coercion

2. Reference Coercion

3. Function Item Coercion

4. Trait Object Coercion

5. Transitivity and Chaining

6. Least Upper Bound Coercion

7. Subtyping and Variance

RustLang #Programming #LearnToCode #STEM #EdTech

📚 Practice Resources

RustLang #Programming #LearnToCode #STEM #EdTech

🦀 Rust Master Class - Chapter 18: Advanced References

🦀 Rust Master Class - Chapter 18: Advanced References

1. Binding and Reference Varieties

2. Destructuring References

3. Borrowing in Compound Data Types

4. Refutable and Irrefutable Patterns

5. Reference and Deref Coercion

6. Subtyping and Variance

RustLang #Programming #LearnToCode #STEM #EdTech

📚 Practice Resources

RustLang #Programming #LearnToCode #STEM #EdTech

🦀 Rust Master Class - Chapter 17: Error Handling

🦀 Rust Master Class - Chapter 17: Error Handling

1. The Option<T> Enum

2. The Result<T, E> Enum

4. Anonymous Lifetimes (`'_`)

1. The `Option<T>` Enum

2. The `Result<T, E>` Enum

3. The Question Mark Operator (`?`)

5. Advanced Error Crates: `anyhow` and `thiserror`

3. The `?Sized` Trait Bound