Rust Programming Study Guide

10. Closures & Iterators Core

Closure Traits: Fn, FnMut, and FnOnce

Closures in Rust capture variables from their environment. The compiler automatically determines which trait a closure implements based on how it uses captured values. This is a hierarchy:

• FnOnce: Consumes (takes ownership of) captured values. Can be called at most once. Use this when the closure needs to move values.
• FnMut: Mutably borrows captured values. Can be called multiple times, but each call may mutate captured state. Use for closures that modify external variables.
• Fn: Immutably borrows captured values. Can be called multiple times without side effects. Most reusable and least restrictive.

The relationship: Every closure is FnOnce. If it doesn't move values, it's also FnMut. If it doesn't mutate, it's also Fn. In other words: Fn ⊆ FnMut ⊆ FnOnce.

Auto-deref coercion: When you pass a closure to a function expecting Fn, Rust is lenient. It will accept FnMut or FnOnce if the function only calls it once or immutably. But a function expecting FnOnce won't accept Fn (you're over-promising).

Explicit capture: Use move keyword to force a closure to take ownership of all captured variables, even if it would normally borrow.

let name = String::from("Alice");

// Fn — captures name immutably, can call many times
let greet = || println!("Hello, {}", name);
greet();
greet();  // OK: called multiple times

// FnMut — captures count mutably, modifies external state
let mut count = 0;
let mut increment = || {
    count += 1;  // mutable borrow
    println!("Count: {}", count);
};
increment();  // Count: 1
increment();  // Count: 2

// FnOnce — takes ownership via move
let name = String::from("Bob");
let consume = move || {
    println!("Name: {}", name);
    drop(name);  // consume/move the value
};
consume();
// consume(); // ERROR: already called (FnOnce)
// println!("{}", name); // ERROR: name was moved into closure

// Function taking FnOnce — closure will be called once, may consume
fn call_once<F: FnOnce()>(f: F) {
    f();
}

// Function taking FnMut — closure may be called multiple times, may mutate
fn call_multiple<F: FnMut()>(mut f: F) {
    f();
    f();
}

// Function taking Fn — closure called multiple times, no side effects
fn call_as_filter<F: Fn(i32) -> bool>(nums: &[i32], predicate: F) -> Vec<i32> {
    nums.iter().copied().filter(predicate).collect()
}

Iterators and Lazy Evaluation

Iterators in Rust are lazy: they don't execute until you call a consuming adapter like .collect(), .sum(), .for_each(), etc. This design enables zero-cost abstractions — the compiler can optimize iterator chains into tight loops.

Iterator adaptors (lazy) — return an iterator, don't execute yet:

• .map(f) — apply closure to each element
• .filter(f) — keep elements where f returns true
• .take(n) — yield first n elements
• .skip(n) — skip first n elements
• .zip(other) — pair elements from two iterators
• .enumerate() — yield (index, element) pairs
• .flat_map(f) — map then flatten

Consuming adaptors (execute the iterator):

• .collect() — gather into a collection (Vec, HashSet, etc.)
• .sum() — sum numeric elements
• .product() — product of elements
• .fold(init, f) — reduce with accumulator
• .for_each(f) — run closure for side effects
• .any(f) — true if any element matches
• .all(f) — true if all elements match
• .find(f) — first element matching predicate
• .max(), .min() — largest/smallest element
• .count() — number of elements

// Lazy evaluation — nothing runs until collect()
let result: Vec<i32> = (1..=100)
    .filter(|x| x % 2 == 0)    // keep evens (lazy)
    .map(|x| x * x)                // square them (lazy)
    .take(5)                      // first 5 (lazy)
    .collect();                     // [4, 16, 36, 64, 100] (execute now)

// Consuming with fold (reduce pattern)
let sum = (1..=5)
    .map(|x| x * x)
    .fold(0, |acc, x| acc + x);  // 1+4+9+16+25 = 55

// any() and all() short-circuit
let has_even = vec![1, 2, 3].iter().any(|x| x % 2 == 0);  // true (stops at 2)

// find() returns Option, stops on first match
let first_even = (1..=10).find(|x| x % 2 == 0);  // Some(2)

// Custom iterator — implement Iterator trait
struct Counter { count: u32, max: u32 }

impl Iterator for Counter {
    type Item = u32;

    fn next(&mut self) -> Option<u32> {
        if self.count < self.max {
            self.count += 1;
            Some(self.count)
        } else {
            None
        }
    }
}

let counter = Counter { count: 0, max: 5 };
let result: Vec<_> = counter.map(|x| x * 2).collect();  // [2, 4, 6, 8, 10]

11. Unsafe Rust Advanced

The Five Unsafe Capabilities

unsafe is not a license to ignore all rules. It only unlocks five specific capabilities that the borrow checker cannot verify statically. The borrow checker still applies inside unsafe blocks — you can't, for example, have two mutable references in a safe way even in unsafe.

The five capabilities are:

1. Dereference raw pointers (*const T and *mut T): Raw pointers can be null or dangling; the compiler can't verify safety.
2. Call unsafe functions or methods: Functions marked unsafe fn have preconditions that only the caller can verify.
3. Access or modify mutable static variables: Global state is inherently unsafe (race conditions).
4. Implement unsafe traits: Some traits have safety invariants (e.g., Send, Sync). Manual impl requires guaranteeing invariants.
5. Access fields of unions: Unions allow overlapping memory; field interpretation is unsafe.

Core principle: You are responsible for verifying the invariants that the compiler can't. Use unsafe sparingly, document invariants with comments, and wrap unsafe code in safe abstractions.

Raw Pointers

Raw pointers (*const T and *mut T) are created safely (e.g., from a reference via as cast), but dereferencing them requires unsafe. They can be null, dangling, or misaligned — the compiler makes no guarantees.

Use cases:

• FFI (Foreign Function Interface): C/C++ libraries return raw pointers.
• Custom data structures: Implementing data structures that need pointer manipulation (linked lists, trees with back-pointers).
• Low-level systems programming: Memory-mapped I/O, hardware access.

// Creating raw pointers is safe
let mut x = 42;
let r1 = &x as *const i32;      // immutable raw pointer from reference
let r2 = &mut x as *mut i32;  // mutable raw pointer

// Dereferencing requires unsafe — compiler can't verify it's valid
unsafe {
    println!("Value: {}", *r1);    // read through raw pointer
    *r2 = 100;                    // write through raw pointer
}

// Null pointer (safe to create, unsafe to dereference)
let null_ptr: *const i32 = std::ptr::null();

unsafe {
    // This would be undefined behavior:
    // println!("{}", *null_ptr);
}

FFI (Foreign Function Interface)

extern "C" blocks declare C functions. Calling them requires unsafe because the Rust compiler can't verify the C function's safety properties or ABI compatibility.

// Declare C functions in extern block
extern "C" {
    fn abs(input: i32) -> i32;
    fn malloc(size: usize) -> *mut u8;
    fn free(ptr: *mut u8);
}

// Calling C functions is unsafe
let result = unsafe { abs(-42) };  // 42

// Wrapping C functions in safe abstractions
fn safe_abs(x: i32) -> i32 {
    unsafe { abs(x) }  // we verify: abs is always safe for i32
}

Mutable Statics

Accessing or modifying static mut variables is unsafe because they introduce global mutable state, which can lead to data races in multi-threaded code. Prefer std::sync::OnceLock or parking_lot::Once for initialization, or std::sync::Mutex for mutable shared state.

// Mutable global state (avoid!)
static mut COUNTER: i32 = 0;

fn increment() {
    unsafe {
        COUNTER += 1;
    }
}

// Better: use OnceLock for initialization
use std::sync::OnceLock;

static CONFIG: OnceLock<String> = OnceLock::new();

fn init_config(val: String) {
    let _ = CONFIG.set(val);  // safe, one-time initialization
}

Safe Abstractions Over Unsafe Code

The power of unsafe is in building safe abstractions. You write unsafe code carefully once, prove its correctness, and expose a safe API to callers. This is how standard library data structures are implemented.

// Safe public API, unsafe implementation details
pub fn split_at_mut(values: &mut [i32], mid: usize) -> (&mut [i32], &mut [i32]) {
    let len = values.len();
    assert!(mid <= len, "index out of bounds");

    let ptr = values.as_mut_ptr();
    unsafe {
        // SAFETY: We verified mid <= len, and ptr is valid for the entire slice.
        // We are returning non-overlapping slices, satisfying the borrow checker.
        (
            std::slice::from_raw_parts_mut(ptr, mid),
            std::slice::from_raw_parts_mut(ptr.add(mid), len - mid),
        )
    }
}

// Caller never sees unsafe — safe interface
let mut data = vec![1, 2, 3, 4];
let (left, right) = split_at_mut(&mut data, 2);
// left: &mut [1, 2], right: &mut [3, 4]

12. Macros Intermediate

Declarative Macros (macro_rules!)

Declarative macros use pattern matching on token streams to generate code at compile time. They are called with ! (e.g., vec!(), println!()). The compiler matches patterns and expands them.

Syntax: macro_rules! name { (pattern) => { expansion }; }

Pattern elements:

• expr — an expression
• stmt — a statement
• ty — a type
• ident — an identifier
• tt — a token tree (any sequence of tokens)
• $(...)* — zero or more repetitions (similar to regex)
• $(,)? — optional trailing separator

Key points:

• Macros operate on token trees, not parsed code. They don't have access to type information.
• Repetition with $(...)* and $(...)+ is common. Each captured group gets a $ prefix in the expansion.
• Declarative macros are powerful for DSLs (domain-specific languages) but can be verbose and hard to debug.

// Simple declarative macro
macro_rules! greet {
    ($name:expr) => {
        println!("Hello, {}", $name);
    };
}

greet!("Alice");  // Hello, Alice

// Macro with repetition — hashmap constructor
macro_rules! hashmap {
    ($($key:expr => $val:expr),* $(,)?) => {{
        let mut map = std::collections::HashMap::new();
        $( map.insert($key, $val); )*  // expand for each key=>val pair
        map
    }};
}

let scores = hashmap! {
    "Alice" => 95,
    "Bob" => 87,
    "Charlie" => 92,
};

// Macro matching different patterns (overloading)
macro_rules! print_type {
    (i32) => { println!("Type is i32"); };
    (String) => { println!("Type is String"); };
    ($ty:ty) => { println!("Type is: {}", stringify!($ty)); };
}

print_type!(i32);      // Type is i32
print_type!(String);  // Type is String

// Built-in macros: stringify!, concat!, etc.
let s = stringify!(x + y);  // "x + y" as string
let combined = concat!("Hello", " ", "World");  // "Hello World"

Procedural Macros

Procedural macros are Rust functions that run at compile time, transforming token streams or AST into new code. They are more powerful than declarative macros but require a separate crate (with proc-macro = true in Cargo.toml).

Three kinds of procedural macros:

1. Derive macros: #[derive(MyTrait)] — automatically implement traits. Most common.
2. Attribute macros: #[my_attribute] — transform entire items (functions, structs, etc.).
3. Function-like macros: my_macro!(...) — behave like declarative macros but with full AST access.

Example use cases:

• #[derive(Serialize, Deserialize)] — from serde, generates serialization code.
• #[tokio::main] — from tokio, wraps main in async runtime setup.
• #[test] — from stdlib, marks functions as tests.

// Standard derive macros (no custom crate needed)
#[derive(Debug, Clone, PartialEq)]
struct Person {
    name: String,
    age: u32,
}

// Using derive-based traits
let p = Person { name: "Alice".into(), age: 30 };
println!("{:?}", p);         // Debug trait
let p2 = p.clone();          // Clone trait

// Popular derive macros from external crates
#[derive(Debug, Serialize, Deserialize)]
struct Config {
    port: u16,
    host: String,
}

// Attribute macros example (tokio::main)
#[tokio::main]
async fn main() {
    // Expands to: fn main() { tokio::runtime::Runtime::new().block_on(async { ... }) }
}

When to Use Each

13. Memory Layout Advanced

Struct Layout and Padding

By default, Rust uses repr(Rust) layout: the compiler may reorder fields to minimize padding and improve cache locality. This is an implementation detail and can change between compiler versions.

#[repr(C)] uses C-compatible layout, matching the rules of the C ABI. This is essential for FFI. Fields are laid out in declaration order, with padding inserted as needed for alignment.

Alignment: Each type has an alignment requirement (usually equal to its size for primitives, but can vary). The compiler pads fields to satisfy alignment.

Example:

#[repr(C)]
struct Packed { a: u8, b: u32, c: u8 }
// Layout:
// a: [u8]           at offset 0 (1 byte, align 1)
// 
// b: [u32]          at offset 4 (4 bytes, align 4)
// c: [u8]           at offset 8 (1 byte, align 1)
// 
// Total: 16 bytes (aligned to u32 boundary)

struct Reordered { a: u8, b: u32, c: u8 }
// Layout (Rust may reorder):
// a: [u8]           at offset 0 (1 byte)
// c: [u8]           at offset 1 (1 byte)
// 
// b: [u32]          at offset 4 (4 bytes)
// Total: 8 bytes

To minimize size, order large fields before small ones.

Enum Layout and Discriminants

Enums store a discriminant (tag) to identify the variant, plus the largest variant's data. The discriminant is typically a small integer.

enum Result<T, E> {
    Ok(T),
    Err(E),
}

// Simplified layout (for 64-bit system):
// discriminant: u32 (0 = Ok, 1 = Err)
// data: max(sizeof(T), sizeof(E))
// Plus padding as needed

Rust's compiler is smart about space. It uses niche optimization to reduce enum sizes when possible.

Niche Optimization

Niche optimization means the compiler reuses invalid values of a type as discriminants. This saves space.

• Option<&T> is the same size as &T because references can never be null. The compiler uses null as the None discriminant.
• Option<bool> is 1 byte (not 2) because bool has unused bit patterns.
• Option<Option<bool>> is still 1 byte — multiple levels of nesting don't add size.
• Option<NonZeroU32> is 4 bytes because NonZeroU32 never contains 0.

use std::mem;
use std::num::NonZeroU32;

// Niche optimization examples
assert_eq!(mem::size_of::<&i32>(), 8);                    // 8 bytes
assert_eq!(mem::size_of::<Option<&i32>>(), 8);         // still 8! (null = None)

assert_eq!(mem::size_of::<bool>(), 1);                 // 1 byte
assert_eq!(mem::size_of::<Option<bool>>(), 1);        // still 1! (2 and 3 unused)

assert_eq!(mem::size_of::<Option<Option<bool>>>(), 1); // still 1!

assert_eq!(mem::size_of::<NonZeroU32>(), 4);        // 4 bytes (never zero)
assert_eq!(mem::size_of::<Option<NonZeroU32>>(), 4); // still 4! (0 = None)

Zero-Sized Types (ZSTs)

A zero-sized type has size 0. The compiler must still distinguish them at compile time (for type checking), but they don't occupy runtime space.

• () — the unit type
• Empty structs: struct Marker;
• PhantomData<T> — a zero-sized marker for ownership/lifetime tracking
• Arrays of ZST: Vec<()> — size is 24 (vec metadata), but contains no actual elements

Use cases:

• Marker types: PhantomData<T> tells Rust "I logically own a T" without storing it. Useful in generics (e.g., lifetime tracking, variance control).
• Compile-time state machines: Different empty types represent different states (see typestate pattern).
• Set implementations: HashSet<T> is often implemented as HashMap<T, ()>.

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

// Zero-sized types
assert_eq!(mem::size_of::<()>(), 0);
assert_eq!(mem::size_of::<Vec<()>>(), 24);  // vec metadata only

// PhantomData for compile-time tracking
struct Owned<T> {
    data: *mut T,
    _phantom: PhantomData<T>,  // ZST, tells compiler "I own T"
}

assert_eq!(mem::size_of::<Owned<i32>>(), 8);  // just the pointer, no overhead

Checking Sizes and Alignment

Use std::mem::size_of(), std::mem::align_of(), and std::mem::size_of_val() to inspect memory layout at runtime (or compile time with const).

use std::mem;

struct Example {
    a: u8,
    b: u32,
    c: u16,
}

println!("size: {}, align: {}", mem::size_of::<Example>(), mem::align_of::<Example>());

// Offset calculation (not stabilized in std, use third-party crate if needed)
let ex = Example { a: 1, b: 2, c: 3 };
let addr_a = &ex.a as *const _ as usize;
let addr_b = &ex.b as *const _ as usize;
println!("offset of b: {}", addr_b - addr_a);

14. Design Patterns Intermediate

Newtype Pattern

// Type safety without runtime cost
struct Meters(f64);
struct Kilometers(f64);

fn travel(distance: Kilometers) { /* ... */ }
// travel(Meters(100.0)); // ERROR: expected Kilometers, got Meters

Builder Pattern

struct Server { host: String, port: u16, max_conn: usize }

struct ServerBuilder { host: String, port: u16, max_conn: usize }

impl ServerBuilder {
    fn new() -> Self {
        Self { host: "0.0.0.0".into(), port: 8080, max_conn: 100 }
    }
    fn host(mut self, host: &str) -> Self { self.host = host.into(); self }
    fn port(mut self, port: u16) -> Self { self.port = port; self }
    fn build(self) -> Server {
        Server { host: self.host, port: self.port, max_conn: self.max_conn }
    }
}

let server = ServerBuilder::new().host("localhost").port(3000).build();

Typestate Pattern

// Compile-time state machine — invalid states are unrepresentable
struct Locked;
struct Unlocked;

struct Door<State> { _state: std::marker::PhantomData<State> }

impl Door<Locked> {
    fn unlock(self) -> Door<Unlocked> {
        println!("Unlocking...");
        Door { _state: std::marker::PhantomData }
    }
}

impl Door<Unlocked> {
    fn open(&self) { println!("Opening door"); }
    fn lock(self) -> Door<Locked> {
        Door { _state: std::marker::PhantomData }
    }
}

let door = Door::<Locked> { _state: std::marker::PhantomData };
// door.open(); // ERROR: no method `open` for Door<Locked>
let door = door.unlock();
door.open(); // OK!

15. Testing Core

// Unit tests — in the same file
#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_add() {
        assert_eq!(add(2, 3), 5);
    }

    #[test]
    #[should_panic(expected = "divide by zero")]
    fn test_divide_by_zero() {
        divide(10, 0);
    }

    #[test]
    fn test_result() -> Result<(), Box<dyn std::error::Error>> {
        let val: i32 = "42".parse()?;
        assert_eq!(val, 42);
        Ok(())
    }
}

// Integration tests — in tests/ directory
// tests/integration_test.rs
use my_crate::public_function;

#[test]
fn integration_test() {
    assert!(public_function(5) > 0);
}

// Property-based testing with proptest
use proptest::prelude::*;

proptest! {
    #[test]
    fn doesnt_crash(s in "\\PC*") {
        let _ = parse(&s);  // should never panic
    }
}

16. Performance Intermediate

Zero-Cost Abstractions

Rust's high-level abstractions (iterators, closures, traits, generics) compile down to the same machine code you'd write by hand. Iterator chains like .map().filter().collect() produce optimized loop code with no heap allocations or virtual dispatch. This is achieved through monomorphization (generics) and inlining, enabling developers to write elegant, composable code without sacrificing performance.

Common Performance Tips

17. Ecosystem & Tooling General

Must-Know Crates

18. Coding Challenges Practice

Challenge 1: Implement a Thread-Safe Cache

use std::collections::HashMap;
use std::sync::{Arc, RwLock};
use std::hash::Hash;

#[derive(Clone)]
struct Cache<K, V> {
    store: Arc<RwLock<HashMap<K, V>>>,
}

impl<K: Eq + Hash + Clone, V: Clone> Cache<K, V> {
    fn new() -> Self {
        Self { store: Arc::new(RwLock::new(HashMap::new())) }
    }

    fn get(&self, key: &K) -> Option<V> {
        self.store.read().unwrap().get(key).cloned()
    }

    fn set(&self, key: K, value: V) {
        self.store.write().unwrap().insert(key, value);
    }

    fn get_or_insert_with(&self, key: K, f: impl FnOnce() -> V) -> V {
        // Try read first (no write lock needed)
        if let Some(val) = self.store.read().unwrap().get(&key) {
            return val.clone();
        }
        // Cache miss — acquire write lock
        let mut store = self.store.write().unwrap();
        // Double-check (another thread may have inserted)
        store.entry(key).or_insert_with(f).clone()
    }
}

Challenge 2: Flatten a Nested Iterator

fn flatten<I>(iter: I) -> Flatten<I>
where
    I: Iterator,
    I::Item: IntoIterator,
{
    Flatten { outer: iter, inner: None }
}

struct Flatten<I: Iterator>
where I::Item: IntoIterator
{
    outer: I,
    inner: Option<<I::Item as IntoIterator>::IntoIter>,
}

impl<I> Iterator for Flatten<I>
where
    I: Iterator,
    I::Item: IntoIterator,
{
    type Item = <I::Item as IntoIterator>::Item;

    fn next(&mut self) -> Option<Self::Item> {
        loop {
            if let Some(ref mut inner) = self.inner {
                if let Some(item) = inner.next() {
                    return Some(item);
                }
            }
            let next_inner = self.outer.next()?.into_iter();
            self.inner = Some(next_inner);
        }
    }
}

// Usage: flatten(vec![vec![1,2], vec![3,4]].into_iter()) → [1,2,3,4]

Challenge 3: Implement a Simple Linked List

type Link<T> = Option<Box<Node<T>>>;

struct Node<T> { val: T, next: Link<T> }

struct List<T> { head: Link<T> }

impl<T> List<T> {
    fn new() -> Self { Self { head: None } }

    fn push(&mut self, val: T) {
        let new_node = Box::new(Node {
            val,
            next: self.head.take(),  // take ownership of old head
        });
        self.head = Some(new_node);
    }

    fn pop(&mut self) -> Option<T> {
        self.head.take().map(|node| {
            self.head = node.next;
            node.val
        })
    }

    fn peek(&self) -> Option<&T> {
        self.head.as_ref().map(|node| &node.val)
    }
}

// Proper Drop to avoid stack overflow on deep lists
impl<T> Drop for List<T> {
    fn drop(&mut self) {
        let mut cur = self.head.take();
        while let Some(mut node) = cur {
            cur = node.next.take();  // iterative drop, not recursive
        }
    }
}

19. System Design in Rust Senior

When to Choose Rust Over Other Languages

Rust excels in several scenarios where other languages fall short:

• Memory safety without GC pauses: Embedded systems and real-time applications require predictable performance without garbage collection overhead.
• High performance + safety: Network services, databases, and game engines benefit from Rust's zero-cost abstractions and compile-time guarantees.
• Fearless concurrency: Data-parallel processing and concurrent algorithms are easier to reason about with Rust's ownership system.
• Long-running services: Services where GC pauses are unacceptable (trading systems, low-latency services) need Rust's deterministic performance.
• WebAssembly targets: Rust's WASM support with excellent tooling (wasm-pack, wasm-bindgen) makes it ideal for performance-critical browser code.
• Security-critical code: Cryptography, OS kernel modules, and trusted computing require the memory safety guarantees that only Rust provides.

Rust in Production: Common Architectures

20. Cheat Sheet

Quick Reference: Ownership & Borrowing

Quick Reference: Common Conversions

Quick Reference: Lifetime Annotations

21. Latest Rust Features (2025–2026)

Rust Edition 2024 (Shipped with 1.85.0)

The largest edition since 2018. Key changes that require edition = "2024" in Cargo.toml:

Stable Release Highlights: 1.85 → 1.94

1.85.0 — Feb 20, 2025 (Edition 2024)

// Async closures — first-class async || {} that properly capture references
let db = &database;
let fetch = async || {
    db.query("SELECT * FROM users").await
};

// Works with the new AsyncFn traits
async fn retry<F: AsyncFn() -> Option<T>, T>(f: F, attempts: u32) -> Option<T> {
    for _ in 0..attempts {
        if let Some(val) = f().await { return Some(val); }
    }
    None
}

// #[diagnostic::do_not_recommend] — hide unhelpful trait suggestions
#[diagnostic::do_not_recommend]
impl<T: Into<String>> MyTrait for T {}

1.86.0 — Apr 3, 2025

// Trait upcasting — coerce dyn SubTrait to dyn SuperTrait automatically
trait Base { fn name(&self) -> &str; }
trait Extended: Base { fn extra(&self); }

fn use_base(obj: &dyn Base) { println!("{}", obj.name()); }

fn example(ext: &dyn Extended) {
    use_base(ext);   // ✅ automatic upcasting! (was error before 1.86)
}

// Disjoint mutable indexing — multiple &mut at different indices
let mut v = vec![1, 2, 3, 4, 5];
let [a, _, b] = v.get_disjoint_mut([0, 2, 4]).unwrap();  // three &mut at once!
*a = 10; *b = 50;

// Safe #[target_feature] on safe functions
#[target_feature(enable = "avx2")]
fn fast_sum(data: &[f32]) -> f32 { /* SIMD code, no unsafe needed */ }

// New APIs: Vec::pop_if, Once::wait, f64::next_up/next_down
let mut v = vec![1, 2, 3];
let popped = v.pop_if(|&mut x| x > 2);  // Some(3)

1.87.0 — May 15, 2025

// Vec::extract_if — drain elements matching a predicate
let mut v = vec![1, 2, 3, 4, 5, 6];
let evens: Vec<_> = v.extract_if(.., |x| *x % 2 == 0).collect();
// evens = [2, 4, 6], v = [1, 3, 5]

1.88.0 — Jun 26, 2025

// let chains in if/while — stabilized for Edition 2024
if let Some(x) = opt && x > 0 && let Some(y) = compute(x) {
    process(x, y);
}
while let Some(item) = iter.next() && item.is_valid() {
    handle(item);
}

// Naked functions — full assembly control with no prologue/epilogue
#[unsafe(naked)]
unsafe extern "C" fn context_switch() {
    core::arch::naked_asm!(
        "push rbp",
        "mov rbp, rsp",
        "pop rbp",
        "ret",
    );
}

// Cell::update — modify in place without get+set
use std::cell::Cell;
let c = Cell::new(5);
c.update(|v| v + 1);  // c is now 6

// Cargo auto-cleans its cache (gc)

1.89.0 — Aug 7, 2025

// #[repr(u128)] / #[repr(i128)] — 128-bit discriminants for enums
#[repr(u128)]
enum BigEnum {
    A = 1 << 100,
    B = 1 << 127,
}

// Explicitly inferred const arguments
fn make_array<const N: usize>() -> [u8; N] { [0; N] }
let arr = make_array::<_>();  // compiler infers N from context

// File locking — cross-platform advisory file locks
use std::fs::File;
let f = File::open("data.lock")?;
f.lock()?;        // blocking exclusive lock
f.try_lock()?;    // non-blocking
f.lock_shared()?; // shared (read) lock
f.unlock()?;

// AVX-512 + SHA-512 + SM3/SM4 target features stabilized

1.90.0 — Sep 18, 2025

// lld is now the default linker on x86_64-unknown-linux-gnu
// → Significantly faster link times for Linux builds
// No code changes needed — just upgrade Rust

1.91.0 — Oct 30, 2025

// Atomic pointer arithmetic operations — lock-free data structures
use std::sync::atomic::{AtomicPtr, Ordering};
let ptr = AtomicPtr::new(base_ptr);
ptr.fetch_ptr_add(4, Ordering::Relaxed);  // atomic pointer offset
ptr.fetch_byte_add(16, Ordering::Relaxed); // byte-level offset

// Duration convenience constructors
use std::time::Duration;
let d = Duration::from_hours(2);  // new!
let d = Duration::from_mins(30);  // new!

// Path::file_prefix — stem before first dot
use std::path::Path;
let p = Path::new("archive.tar.gz");
assert_eq!(p.file_prefix(), Some("archive".as_ref()));
// vs file_stem() → "archive.tar"

// C-style variadic functions for sysv64, win64, efiapi ABIs
// Cargo build.build-dir config for custom artifact directories

1.92.0 — Dec 11, 2025

// RwLockWriteGuard::downgrade — writer → reader without releasing
use std::sync::RwLock;
let lock = RwLock::new(vec![1, 2, 3]);
let mut write = lock.write().unwrap();
write.push(4);
let read = write.downgrade();  // ✅ atomic downgrade, no gap
println!("{:?}", &*read);

// Zero-initialized smart pointers
let b: Box<[u8; 4096]> = Box::new_zeroed();  // all zeros, no stack copy
let b = unsafe { b.assume_init() };

// Also for Rc and Arc
let arc_slice: Arc<[u8]> = Arc::new_zeroed_slice(1024);

// BTreeMap entry improvements
use std::collections::BTreeMap;
let mut map = BTreeMap::new();
let entry = map.entry("key").insert_entry(42);  // returns OccupiedEntry

1.93.0 — Jan 22, 2026

// C-style variadic functions for system ABI — stabilized
pub unsafe extern "system" fn variadic_fn(fmt: *const c_char, ...) { }

// asm_cfg — use #[cfg] inside asm! blocks
core::arch::asm!(
    #[cfg(target_arch = "x86_64")]
    "nop",
    #[cfg(target_arch = "aarch64")]
    "nop",
);

// Const-eval: pointer copying byte-by-byte in const context
// s390x vector features + is_s390x_feature_detected! macro

1.94.0 — Mar 5, 2026 (Current Stable)

// array_windows — const-sized sliding windows over slices
let data = [1, 2, 3, 4, 5];
for window in data.array_windows::<3>() {
    // window is &[i32; 3], not &[i32]
    println!("{window:?}");  // [1,2,3], [2,3,4], [3,4,5]
}

// element_offset — find position of element by reference
let v = vec![10, 20, 30];
let r = &v[1];
assert_eq!(v.element_offset(r), Some(1));

// LazyCell/LazyLock accessor methods
use std::sync::LazyLock;
static CONFIG: LazyLock<String> = LazyLock::new(|| "loaded".into());
let val: Option<&String> = LazyLock::get(&CONFIG);  // None if not yet init'd
LazyLock::force(&CONFIG);
let val = LazyLock::get(&CONFIG);  // Some("loaded")

// Peekable::next_if_map
let mut iter = vec![1, 2, 3].into_iter().peekable();
let doubled = iter.next_if_map(|&x| if x < 3 { Some(x * 2) } else { None });

// Mathematical constants: EULER_GAMMA and GOLDEN_RATIO
use std::f64::consts::{EULER_GAMMA, GOLDEN_RATIO};
println!("γ = {EULER_GAMMA}");   // 0.5772156649...
println!("φ = {GOLDEN_RATIO}");  // 1.6180339887...

// f32/f64::mul_add now const-stable
const RESULT: f64 = (3.0_f64).mul_add(4.0, 5.0);  // 17.0 at compile time

// Unicode 17 support
// AVX-512 FP16 + AArch64 NEON FP16 intrinsics stabilized
// Cargo: include config key, TOML v1.1 parsing, pubtime in registry

Nightly / Upcoming Features (1.95–1.96+)

gen Blocks — Generator-Based Iterators

Create iterators without boilerplate structs. The gen keyword turns a block into an iterator using yield. Still on nightly; RFC 3513 accepted, active development ongoing:

#![feature(gen_blocks)]

fn fibonacci() -> impl Iterator<Item = u64> {
    gen {
        let (mut a, mut b) = (0, 1);
        loop {
            yield a;
            (a, b) = (b, a + b);
        }
    }
}

// async gen blocks for async streams
async gen {
    for url in urls {
        yield reqwest::get(url).await?.text().await?;
    }
}

Tail Calls via become

#![feature(explicit_tail_calls)]

fn factorial(n: u64, acc: u64) -> u64 {
    if n <= 1 { acc }
    else { become factorial(n - 1, n * acc) }  // guaranteed TCO
}

Pin Ergonomics

#![feature(pin_ergonomics)]

// &pin mut T replaces Pin<&mut T>
async fn process(data: &pin mut MyFuture) { data.poll().await; }

// Auto-reborrowing: reuse Pin without Pin::as_mut()
fn takes_pin(x: Pin<&mut Foo>) {
    helper(x);  // auto re-pin
    helper(x);  // can reuse!
}

Reflection (Tracking Issue #142577)

#![feature(reflection)]

// Compile-time type introspection for derive macros and serialization
// Early stage — API still evolving

Sized Hierarchy & Scalable Vectors (2026 Goal)

Stabilizing a Sized trait hierarchy as a standalone win that unblocks extern type. SVE (Scalable Vector Extension) intrinsics continuing as a nightly experiment.

Other Nightly Features in Progress

Ecosystem Milestones (2025–2026)

22. Advanced Deep Dive

Variance & Subtyping

Rust has subtyping only through lifetimes. Variance determines how type constructors relate to lifetime subtyping:

// If 'long: 'short (long outlives short), then:
//   &'long T  can be used where &'short T is expected  (covariant in 'a)
//   &'a mut T is INVARIANT in T — cannot substitute

// Covariant: &'a T, *const T, Vec<T>, Box<T>, Option<T>
// Contravariant: fn(T) (in argument position)
// Invariant: &'a mut T (in T), Cell<T>, UnsafeCell<T>

// Why invariance matters:
fn evil(input: &mut &'static str, short: &str) {
    // If &mut T were covariant in T, this would compile:
    // *input = short;  // Would let a &'static str point to short-lived data!
    // Rust prevents this by making &mut T invariant in T.
}

// PhantomData controls variance
use std::marker::PhantomData;

struct Deserializer<'de> {
    data: *const u8,
    _marker: PhantomData<&'de [u8]>,  // Covariant in 'de
}

struct MutRef<'a, T> {
    ptr: *mut T,
    _marker: PhantomData<&'a mut T>,  // Invariant in T and 'a
}

// Contravariance example
struct ContravariantLifetime<'a> {
    _marker: PhantomData<fn(&'a ())>,  // Contravariant in 'a
}

Higher-Ranked Trait Bounds (HRTBs)

// "for any lifetime 'a, F must implement Fn(&'a str) -> &'a str"
fn apply_to_ref<F>(f: F, s: &str) -> &str
where
    F: for<'a> Fn(&'a str) -> &'a str,
{
    f(s)
}

// Most common in closure bounds — Fn(&T) desugars to for<'a> Fn(&'a T)
fn filter_refs<F>(data: &[String], predicate: F) -> Vec<&str>
where
    F: for<'a> Fn(&'a str) -> bool,
{
    data.iter().filter(|s| predicate(s)).map(|s| s.as_str()).collect()
}

// HRTB with traits
trait Processor {
    fn process<'a>(&self, input: &'a [u8]) -> &'a [u8];
}

fn run<P: Processor>(p: &P, data: &[u8]) -> Vec<u8> {
    p.process(data).to_vec()
}

Generic Associated Types (GATs)

// GATs allow associated types to have their own generic parameters
trait LendingIterator {
    type Item<'a> where Self: 'a;
    fn next<'a>(&'a mut self) -> Option<Self::Item<'a>>;
}

// Classic use case: iterator that yields references to self
struct WindowsMut<'w, T> {
    data: &'w mut [T],
    pos: usize,
    size: usize,
}

impl<'w, T> LendingIterator for WindowsMut<'w, T> {
    type Item<'a> = &'a mut [T] where Self: 'a;

    fn next<'a>(&'a mut self) -> Option<Self::Item<'a>> {
        if self.pos + self.size > self.data.len() {
            return None;
        }
        let slice = &mut self.data[self.pos..self.pos + self.size];
        self.pos += 1;
        Some(slice)
    }
}

// GATs with type parameters
trait Collection {
    type Iter<'a, T: 'a>: Iterator<Item = &'a T> where Self: 'a;
}

// GAT-powered async trait (pre-AFIT pattern)
trait AsyncIterator {
    type Item;
    type Future<'a>: Future<Output = Option<Self::Item>> + 'a where Self: 'a;
    fn next(&mut self) -> Self::Future<'_>;
}

Type-Level Programming

// Typestate pattern — encoding state in the type system
struct Locked;
struct Unlocked;

struct Door<State> {
    _state: PhantomData<State>,
}

impl Door<Locked> {
    fn unlock(self) -> Door<Unlocked> {
        Door { _state: PhantomData }
    }
}

impl Door<Unlocked> {
    fn lock(self) -> Door<Locked> {
        Door { _state: PhantomData }
    }
    fn open(&self) { println!("Door is open"); }
}

// Compile-time dimensional analysis
struct Length<const METERS: i32, const SECONDS: i32>(f64);

type Meters = Length<1, 0>;
type Seconds = Length<0, 1>;
type MetersPerSecond = Length<1, -1>;

// Peano numbers at the type level
struct Zero;
struct Succ<N>(PhantomData<N>);

trait Nat { const VALUE: usize; }
impl Nat for Zero { const VALUE: usize = 0; }
impl<N: Nat> Nat for Succ<N> { const VALUE: usize = N::VALUE + 1; }

type One = Succ<Zero>;
type Two = Succ<One>;
type Three = Succ<Two>;

Drop Check & PhantomData Patterns

// Drop check: compiler ensures T is alive when a type implementing Drop is dropped
// The #[may_dangle] attribute opts out of this check for specific parameters

unsafe impl<#[may_dangle] T> Drop for MyVec<T> {
    fn drop(&mut self) {
        // We promise not to access T during drop
        // Only deallocating memory, not reading T values
        unsafe { dealloc(self.ptr as *mut u8, self.layout()); }
    }
}

// PhantomData patterns summary:
// PhantomData<T>         — owns T, drops T, covariant
// PhantomData<&'a T>     — borrows T, covariant in both 'a and T
// PhantomData<&'a mut T> — mutably borrows T, covariant in 'a, invariant in T
// PhantomData<fn(T)>     — contravariant in T
// PhantomData<fn() -> T> — covariant in T, no drop
// PhantomData<*const T>  — covariant, no Send/Sync
// PhantomData<*mut T>    — invariant, no Send/Sync

Auto Traits & Negative Impls

// Auto traits: Send, Sync, Unpin, UnwindSafe, RefUnwindSafe
// Automatically implemented unless a field opts out

// Why Rc<T> is not Send:
// Rc uses NonNull<RcBox<T>> internally
// NonNull<T> is !Send and !Sync
// So Rc<T> inherits !Send, !Sync

// Negative impls (nightly or via PhantomData)
// impl !Send for MyType {}     // nightly
struct NotSend {
    _marker: PhantomData<*const ()>,  // stable way to be !Send + !Sync
}

// Asserting traits at compile time
fn assert_send<T: Send>() {}
fn assert_sync<T: Sync>() {}

fn check_traits() {
    assert_send::<Vec<i32>>();       // OK
    assert_sync::<Arc<Mutex<i32>>>(); // OK
    // assert_send::<Rc<i32>>();      // FAILS — Rc is !Send
    // assert_sync::<Cell<i32>>();     // FAILS — Cell is !Sync
}

Orphan Rules & Coherence

// The orphan rule: you can only impl a trait for a type if:
//   1. The trait is defined in your crate, OR
//   2. The type is defined in your crate
//
// At least one of (trait, type) must be local.

// ALLOWED: local trait on foreign type
trait MyTrait {}
impl MyTrait for Vec<i32> {}

// ALLOWED: foreign trait on local type
struct MyType;
impl Display for MyType { /* ... */ }

// FORBIDDEN: foreign trait on foreign type
// impl Display for Vec<i32> {} // ERROR!

// Workaround: the newtype pattern
struct Wrapper(Vec<i32>);
impl Display for Wrapper {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "[{}]", self.0.iter()
            .map(|n| n.to_string())
            .collect::<Vec<_>>()
            .join(", "))
    }
}

// Fundamental types (#[fundamental]) relax the orphan rule:
// &T, &mut T, Box<T>, Pin<T> are fundamental
// So you CAN do: impl MyTrait for &ForeignType {}

Advanced Unsafe: Aliasing, Provenance & Stacked/Tree Borrows

// Stacked Borrows — the original aliasing model for unsafe Rust
// Each memory location has a "borrow stack":
// - &mut pushes Unique
// - & pushes SharedReadOnly
// - Raw pointers push SharedReadWrite
// Access must match the top of the stack; violations are UB

// Tree Borrows (2025) — more permissive replacement
// Instead of a stack, uses a tree structure
// Allows more interleaving of raw pointer access
// Still detected by Miri

// Example: this is UB under Stacked Borrows but may be valid under Tree Borrows
fn example() {
    let mut x = 42;
    let ptr1 = &mut x as *mut i32;
    let ptr2 = ptr1;  // derived from ptr1

    unsafe {
        *ptr2 = 10;   // Access via ptr2
        *ptr1 = 20;   // Access via ptr1 — invalidates ptr2 under Stacked Borrows
        // *ptr2 = 30; // UB under Stacked Borrows; OK under Tree Borrows
    }
}

// Pointer provenance: where a pointer "came from" determines what it can access
use std::ptr;

fn provenance_example() {
    let a = 1u32;
    let b = 2u32;
    let ptr_a: *const u32 = &a;
    let ptr_b: *const u32 = &b;

    // Even if ptr_a and ptr_b happen to be adjacent in memory,
    // you CANNOT use pointer arithmetic on ptr_a to reach b.
    // The provenance of ptr_a only covers 'a'.
    // Use strict_provenance APIs:
    let addr = ptr_a.addr();          // Extract address (usize)
    let new_ptr = ptr_b.with_addr(addr);  // Attach addr to ptr_b's provenance
}

// Always validate unsafe code with Miri:
// cargo +nightly miri run
// cargo +nightly miri test

Advanced Const Generics

// Type-safe matrix multiplication with const generics
struct Matrix<const R: usize, const C: usize> {
    data: [[f64; C]; R],
}

impl<const R: usize, const C: usize> Matrix<R, C> {
    fn multiply<const C2: usize>(&self, rhs: &Matrix<C, C2>) -> Matrix<R, C2> {
        let mut result = [[0.0; C2]; R];
        for i in 0..R {
            for j in 0..C2 {
                for k in 0..C {
                    result[i][j] += self.data[i][k] * rhs.data[k][j];
                }
            }
        }
        Matrix { data: result }
    }
}

// Dimension mismatch is a compile-time error:
let a: Matrix<2, 3> = /* ... */;
let b: Matrix<3, 4> = /* ... */;
let c: Matrix<2, 4> = a.multiply(&b);  // OK: (2x3) * (3x4) = (2x4)
// let d = a.multiply(&a);  // ERROR: (2x3) * (2x3) — dimension mismatch!

// Const generic bounds (nightly)
#![feature(generic_const_exprs)]

fn split_array<T, const N: usize, const M: usize>(
    arr: [T; N + M],
) -> ([T; N], [T; M]) {
    // Split array at compile-time-known boundary
    todo!()
}

Advanced Async Patterns

use std::pin::Pin;
use std::future::Future;
use std::task::{Context, Poll};

// Manual Future implementation
struct Delay {
    when: Instant,
}

impl Future for Delay {
    type Output = ();

    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
        if Instant::now() >= self.when {
            Poll::Ready(())
        } else {
            let waker = cx.waker().clone();
            let when = self.when;
            std::thread::spawn(move || {
                std::thread::sleep(when - Instant::now());
                waker.wake();
            });
            Poll::Pending
        }
    }
}

// Select pattern — race multiple futures
use tokio::select;

async fn timeout_fetch(url: &str) -> Result<String, &'static str> {
    select! {
        result = reqwest::get(url) => {
            Ok(result.map_err(|_| "fetch error")?.text().await.map_err(|_| "read error")?)
        }
        _ = tokio::time::sleep(Duration::from_secs(5)) => {
            Err("timeout")
        }
    }
}

// Cancellation-safe streams with pin_project
use pin_project::pin_project;

#[pin_project]
struct Throttle<S> {
    #[pin]
    stream: S,
    #[pin]
    delay: Option<tokio::time::Sleep>,
    interval: Duration,
}

// Self-referential async state machines with Pin
struct AsyncStateMachine {
    state: State,
    buffer: Vec<u8>,
    // Can't hold a reference to buffer without Pin
}

Specialization (Nightly)

#![feature(specialization)]

trait Log {
    fn log(&self);
}

// Default implementation for all Display types
impl<T: Display> Log for T {
    default fn log(&self) {
        println!("{}", self);
    }
}

// Specialized implementation for String — overrides the default
impl Log for String {
    fn log(&self) {
        println!("[String] {}", self);
    }
}

// min_specialization: a safer subset (used internally by std)
#![feature(min_specialization)]

// Only allows specializing with marker traits and specific patterns

23. Difficult Interview Questions

fn longest(x: &str, y: &str) -> &str {
    if x.len() > y.len() { x } else { y }
}

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}
// Now the compiler knows the return value lives at least as long as
// the shorter of the two input lifetimes.

fn apply<F: FnOnce() -> String>(f: F) -> String { f() }
fn apply_ref<F: Fn() -> String>(f: &F) -> String { f() }

let s = String::from("hello");
let closure = move || s;  // FnOnce — consumes s
apply(closure);
// apply_ref(&closure);  // ERROR: closure is FnOnce, not Fn

pub struct SafeWrapper {
    ptr: *mut u8,
    len: usize,
    cap: usize,
}

impl SafeWrapper {
    /// SAFETY: All public methods maintain these invariants:
    /// 1. ptr is non-null and points to a valid allocation of `cap` bytes
    /// 2. First `len` bytes are initialized
    /// 3. cap >= len
    /// 4. No aliasing &mut references exist to the underlying data

    pub fn push(&mut self, byte: u8) {
        if self.len == self.cap {
            self.grow();  // Private, maintains invariants
        }
        // SAFETY: len < cap after grow(), so ptr.add(len) is in bounds
        unsafe { self.ptr.add(self.len).write(byte); }
        self.len += 1;
    }
}

async fn example() -> i32 {
    let a = fetch().await;  // yield point 1
    let b = process(a).await;  // yield point 2
    a + b
}

// Becomes roughly:
enum ExampleFuture {
    Start,
    AfterFetch { fetch_fut: FetchFuture },
    AfterProcess { a: i32, proc_fut: ProcessFuture },
    Done,
}

impl Future for ExampleFuture {
    type Output = i32;
    fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<i32> {
        loop {
            match self.state {
                Start => { /* create fetch_fut, transition */ }
                AfterFetch { ref mut fetch_fut } => {
                    let a = ready!(Pin::new(fetch_fut).poll(cx));
                    // transition to AfterProcess
                }
                AfterProcess { a, ref mut proc_fut } => {
                    let b = ready!(Pin::new(proc_fut).poll(cx));
                    return Poll::Ready(a + b);
                }
                Done => panic!("polled after completion"),
            }
        }
    }
}

// FnOnce: can be called once (takes self by value)
// FnMut: can be called multiple times (takes &mut self)
// Fn: can be called multiple times (takes &self)
// Fn: FnMut: FnOnce — every Fn is also FnMut and FnOnce

fn call_once<F: FnOnce() -> R, R>(f: F) -> R { f() }
fn call_many<F: Fn() -> R, R>(f: &F, times: usize) -> Vec<R> {
    (0..times).map(|_| f()).collect()
}

// The most permissive bound: FnOnce (accepts all closures)
// The most restrictive bound: Fn (only closures that don't mutate or consume)

// Key insight: Box<dyn FnOnce()> was long uncallable because calling
// requires moving out of the Box. Solution: Box<dyn FnOnce()> now has
// a special lang-item call implementation.

use std::borrow::Cow;

fn normalize_path(path: &str) -> Cow<'_, str> {
    if path.contains("//") {
        // Only allocate when we actually need to modify
        Cow::Owned(path.replace("//", "/"))
    } else {
        // Zero-cost: just returns a reference
        Cow::Borrowed(path)
    }
}

// In a web server processing 1M requests:
// ~95% of paths are clean → Cow::Borrowed (zero allocation)
// ~5% need normalization → Cow::Owned (allocates only when needed)
// vs. always returning String: saves ~950K heap allocations

use std::mem::MaybeUninit;

let mut arr: [MaybeUninit<String>; 3] = [
    MaybeUninit::uninit(),
    MaybeUninit::uninit(),
    MaybeUninit::uninit(),
];

arr[0].write(String::from("a"));
arr[1].write(String::from("b"));
arr[2].write(String::from("c"));

// SAFETY: all elements initialized above
let arr: [String; 3] = unsafe {
    MaybeUninit::array_assume_init(arr)
};

// Only accepts Sized types (default)
fn print_sized<T: Display>(val: &T) { println!("{val}"); }

// Accepts DSTs too — can take &str, &[i32], &dyn Display
fn print_any<T: Display + ?Sized>(val: &T) { println!("{val}"); }

print_any("hello");          // T = str (unsized)
print_any(&42);              // T = i32 (sized)
print_any(&vec![1,2] as &dyn Display);  // T = dyn Display (unsized)

use std::sync::OnceLock;

// Modern approach: OnceLock (stable since 1.70)
static CONFIG: OnceLock<AppConfig> = OnceLock::new();

fn get_config() -> &'static AppConfig {
    CONFIG.get_or_init(|| {
        AppConfig::load_from_file("config.toml")
            .expect("failed to load config")
    })
}

// LazyLock (stable since 1.80): combines OnceLock + init fn
use std::sync::LazyLock;

static DB_POOL: LazyLock<DbPool> = LazyLock::new(|| {
    DbPool::connect("postgres://localhost/mydb")
        .expect("failed to connect")
});

// Tradeoffs:
// + Thread-safe, zero-cost after first access (just a pointer load)
// + No external crates needed (was once_cell/lazy_static)
// - Global mutable state makes testing harder
// - Initialization errors are hard to handle (panic in static init)
// - Consider dependency injection instead for testability

// Pre-NLL (Rust < 2018): borrows lasted until end of scope
// NLL: borrows end at last use point

fn example(map: &mut HashMap<String, Vec<i32>>, key: &str) {
    // With NLL, the immutable borrow of `map` via `get` ends after the match
    match map.get(key) {
        Some(v) if !v.is_empty() => {
            println!("found: {:?}", v);
            // NLL: borrow of map from `get` ends here (last use of v)
        }
        _ => {
            // NLL allows this mutable borrow because the immutable one ended
            map.insert(key.to_string(), vec![42]);
        }
    }
}
// Pre-NLL: this would fail because `get`'s borrow lived until `}`
// NLL: compiles fine because the borrow dies at last use of `v`

use std::collections::HashMap;

let mut scores: HashMap<String, Vec<i32>> = HashMap::new();

// BAD: double lookup + borrow conflict
// if !scores.contains_key("alice") {
//     scores.insert("alice".into(), vec![]);
// }
// scores.get_mut("alice").unwrap().push(100);

// GOOD: single lookup via Entry API
scores.entry("alice".into())
    .or_insert_with(Vec::new)
    .push(100);

// Entry variants:
// .or_insert(default)      — insert if empty
// .or_insert_with(|| val)  — lazy init
// .or_default()            — uses Default::default()
// .and_modify(|v| ...)     — modify if exists
// .key()                   — inspect the key

// Why it's better:
// 1. Single hash computation + single probe
// 2. Avoids borrow checker issues (get borrows immutably, insert needs &mut)
// 3. More concise and idiomatic

use std::cell::Cell;

struct Arena {
    buf: Vec<u8>,
    offset: Cell<usize>,
}

impl Arena {
    fn new(capacity: usize) -> Self {
        Arena {
            buf: vec![0u8; capacity],
            offset: Cell::new(0),
        }
    }

    fn alloc<T>(&self, val: T) -> &mut T {
        let align = std::mem::align_of::<T>();
        let size = std::mem::size_of::<T>();
        let mut off = self.offset.get();

        // Align the offset
        off = (off + align - 1) & !(align - 1);
        assert!(off + size <= self.buf.len(), "arena out of memory");

        let ptr = unsafe { self.buf.as_ptr().add(off) as *mut T };
        unsafe { ptr.write(val); }
        self.offset.set(off + size);
        unsafe { &mut *ptr }
    }
}

// Usage: all allocations freed at once when Arena drops
let arena = Arena::new(4096);
let x = arena.alloc(42i32);
let s = arena.alloc(String::from("hello"));
// No individual frees — entire arena freed on drop

// Why arenas? Batch deallocation (compilers, ECS, game frames),
// cache-friendly (contiguous memory), faster than individual heap allocs,
// natural fit for phase-based workloads. Production crate: bumpalo.

24. Quick Revision — The Rust Book

The Three Ownership Rules

1. Each value in Rust has exactly ONE owner.
2. There can only be one owner at a time.
3. When the owner goes out of scope, the value is dropped.

Stack vs Heap — When It Matters

Move vs Copy vs Clone

let s1 = String::from("hello");
let s2 = s1;            // MOVE — s1 is now invalid
// println!("{s1}");     // ERROR: value moved

let s3 = s2.clone();    // CLONE — deep copy, both valid
println!("{s2} {s3}");   // OK

let x = 42;
let y = x;              // COPY — x is still valid (i32 implements Copy)
println!("{x} {y}");     // OK

The Two Borrowing Rules

At any given time, you can have EITHER:
  • ONE mutable reference  (&mut T)
  • ANY number of immutable references  (&T)
  — but NEVER both simultaneously.

All references must always be valid (no dangling).

Borrowing Gotchas & NLL

let mut s = String::from("hello");

let r1 = &s;       // OK — immutable borrow
let r2 = &s;       // OK — multiple immutable borrows
println!("{r1} {r2}");
// r1 and r2 are no longer used after this point (NLL)

let r3 = &mut s;   // OK — NLL: immutable borrows ended at last use
r3.push_str(" world");

// Dangling reference prevention:
// fn dangle() -> &String {
//     let s = String::from("hello");
//     &s   // ERROR: s dropped at end of function
// }
// Fix: return the owned String instead

Lifetime Elision Rules

The compiler applies these rules IN ORDER to infer lifetimes:

Rule 1: Each reference parameter gets its own lifetime.
  fn f(a: &str, b: &str) → fn f<'a, 'b>(a: &'a str, b: &'b str)

Rule 2: If exactly ONE input lifetime, it's assigned to ALL outputs.
  fn f(s: &str) -> &str → fn f<'a>(s: &'a str) -> &'a str

Rule 3: If &self or &mut self is a param, self's lifetime → all outputs.
  fn method(&self, s: &str) -> &str → output gets self's lifetime

If rules don't resolve all lifetimes → you must annotate explicitly.

Structs with Lifetimes

// A struct holding a reference MUST declare the lifetime
struct ImportantExcerpt<'a> {
    part: &'a str,   // part must live at least as long as 'a
}

let novel = String::from("Call me Ishmael. Some years ago...");
let first = novel.split('.').next().unwrap();
let excerpt = ImportantExcerpt { part: first };
// excerpt cannot outlive novel (which owns the str data)

Traits — Core Patterns

// Define a trait
trait Summary {
    fn summarize(&self) -> String;

    // Default implementation (can be overridden)
    fn preview(&self) -> String {
        format!("Read more: {}", self.summarize())
    }
}

// Implement on a type
impl Summary for Article {
    fn summarize(&self) -> String { self.title.clone() }
}

// Trait bounds — three equivalent syntaxes:
fn notify(item: &impl Summary) { }                // sugar
fn notify<T: Summary>(item: &T) { }               // bound
fn notify<T>(item: &T) where T: Summary { }       // where clause

// Multiple bounds
fn display_summary(item: &(impl Summary + Display)) { }

// Return impl Trait (one concrete type only)
fn make_summary() -> impl Summary { Article { /* ... */ } }

// Blanket implementation
impl<T: Display> ToString for T { /* std does this */ }

Coherence & Orphan Rule

You can impl a trait for a type ONLY IF:
  • The trait is local to your crate, OR
  • The type is local to your crate.

// OK:  local trait + foreign type
trait MyTrait {}
impl MyTrait for Vec<i32> {}

// OK:  foreign trait + local type
struct MyType;
impl Display for MyType { /* ... */ }

// ERROR: foreign trait + foreign type
// impl Display for Vec<i32> {}

// Workaround: newtype pattern
struct Wrapper(Vec<i32>);
impl Display for Wrapper { /* ... */ }

Pattern Matching — Complete Rules

match value {
    Pattern => expression,       // literal, struct, enum, tuple
    Pattern if guard => expr,    // match guard
    x @ 1..=5 => use(x),        // bind + range
    (a, b, ..) => use(a, b),    // ignore rest with ..
    Some(ref x) => borrow(x),   // borrow instead of move
    _ => default,               // catch-all (must be last)
}

// Exhaustiveness: ALL variants must be handled. Compiler enforces this.
// Non-exhaustive: _ or named catch-all handles remaining cases.

// if let — when you only care about one variant:
if let Some(val) = option { use(val); }

// while let — loop while pattern matches:
while let Some(top) = stack.pop() { process(top); }

// let-else (stable since 1.65):
let Some(val) = option else { return Err("missing"); };

Error Handling Decision Tree

                  Can it fail?
                 /           \
               No             Yes
               |               |
          just return     Is it recoverable?
                         /              \
                       No               Yes
                       |                 |
                   panic!()        Result<T, E>
                   .unwrap()           |
                   .expect()    Propagate with ?
                                or handle with match

// The ? operator — early return on Err:
fn read_file() -> Result<String, io::Error> {
    let mut s = String::new();
    File::open("data.txt")?.read_to_string(&mut s)?;
    Ok(s)
}

// ? on Option — early return on None:
fn first_char(text: &str) -> Option<char> {
    text.lines().next()?.chars().next()
}

// ? in main():
fn main() -> Result<(), Box<dyn Error>> {
    let f = File::open("config.toml")?;
    Ok(())
}

Smart Pointer Decision Tree

Closures — Capture & Trait Hierarchy

// Capture modes (compiler picks the least restrictive):
let x = String::from("hi");

let borrow_closure = || println!("{x}");         // borrows &x     → Fn
let mut v = vec![1,2];
let mut_closure = || v.push(3);                  // borrows &mut v → FnMut
let consume_closure = move || drop(x);           // moves x        → FnOnce

// Trait hierarchy: Fn ⊂ FnMut ⊂ FnOnce
// Every Fn also implements FnMut and FnOnce.
// Choose the most permissive bound your API needs:
//   FnOnce — accepts all closures (most flexible for caller)
//   Fn     — callable many times through &self (most restrictive)

Concurrency — Thread Safety Quick Ref

// Spawn a thread
let handle = thread::spawn(move || {
    // `move` forces capture by value (required for thread safety)
    expensive_work()
});
let result = handle.join().unwrap();

// Mutex — mutual exclusion
let data = Arc::new(Mutex::new(0));
let data_clone = Arc::clone(&data);
thread::spawn(move || {
    let mut num = data_clone.lock().unwrap();
    *num += 1;
    // MutexGuard dropped here → lock released automatically
});

// Channel — message passing
let (tx, rx) = mpsc::channel();
thread::spawn(move || { tx.send(42).unwrap(); });
let val = rx.recv().unwrap();  // blocks until message arrives

Send & Sync — Thread Safety Markers

// Rule: T is Sync if &T is Send.
// Both are auto-traits — compiler derives them from field types.
// Manual unsafe impl only when wrapping raw pointers with proper sync.

Async / Await — Mental Model

// async fn returns a Future (lazy — does nothing until polled)
async fn fetch_data(url: &str) -> Result<String, Error> {
    let response = reqwest::get(url).await?;  // yield point
    let body = response.text().await?;         // yield point
    Ok(body)
}

// .await suspends the current task, yields to the runtime.
// The runtime polls the Future again when I/O is ready.
// Futures are state machines — each .await = a state transition.

// Key distinction:
// Concurrency ≠ Parallelism
//   Concurrent: one thread interleaves multiple tasks (async)
//   Parallel:   multiple threads execute simultaneously (rayon, threads)

// CPU-bound work in async context:
// BAD:  heavy_compute() inside async task → blocks the runtime thread
// GOOD: tokio::task::spawn_blocking(|| heavy_compute())

Unsafe Rust — The Five Superpowers

unsafe {
    // 1. Dereference a raw pointer
    let ptr = &val as *const i32;
    let val = *ptr;

    // 2. Call an unsafe function
    dangerous_function();

    // 3. Access or modify a mutable static variable
    COUNTER += 1;

    // 4. Implement an unsafe trait
    // unsafe impl Send for MyType {}

    // 5. Access fields of a union
    // let f = my_union.field1;
}

// unsafe does NOT turn off the borrow checker!
// It only unlocks these 5 capabilities.
// Minimize unsafe scope. Document safety invariants.
// Validate with: cargo +nightly miri test

Advanced Traits — Quick Reference

// Associated types (one concrete type per impl, unlike generics)
trait Iterator {
    type Item;                              // associated type
    fn next(&mut self) -> Option<Self::Item>;
}

// Default type parameters
trait Add<Rhs = Self> {                     // Rhs defaults to Self
    type Output;
    fn add(self, rhs: Rhs) -> Self::Output;
}

// Operator overloading
impl Add for Point {
    type Output = Point;
    fn add(self, other: Point) -> Point {
        Point { x: self.x + other.x, y: self.y + other.y }
    }
}

// Fully qualified syntax (disambiguation)
<Type as Trait>::method(&instance);

// Supertraits (trait requires another trait)
trait PrettyPrint: Display {
    fn pretty(&self) -> String;
}
// Any type implementing PrettyPrint must also implement Display.

Common Conversions Cheat Sheet

Iterator Essentials

// Adapters (lazy — produce new iterators):
.map(|x| x * 2)       .filter(|x| x > &5)     .enumerate()
.zip(other)            .chain(other)            .take(n)
.skip(n)               .flatten()               .peekable()
.inspect(|x| dbg!(x))

// Consumers (eager — drive the iterator):
.collect::<Vec<_>>()  .sum::<i32>()           .count()
.any(|x| cond)        .all(|x| cond)           .find(|x| cond)
.fold(init, |acc, x| acc + x)                   .for_each(|x| use(x))

// Performance: iterators compile to the same code as hand-written loops
// (zero-cost abstraction via monomorphization).

String Types Decision Guide

Cargo & Tooling Essentials

cargo new my_project         # create binary project
cargo new --lib my_lib       # create library project
cargo build --release        # optimized build
cargo test                   # run all tests
cargo test test_name         # run specific test
cargo clippy                 # lint for common mistakes
cargo fmt                    # format code
cargo doc --open             # generate & open docs
cargo bench                  # run benchmarks
cargo +nightly miri test     # detect undefined behavior
cargo tree                   # dependency graph
cargo update                 # update deps within semver
cargo audit                  # check for security advisories

Testing Patterns

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn basic_test() {
        assert_eq!(add(2, 3), 5);
    }

    #[test]
    fn with_message() {
        assert!(result.is_ok(), "Expected Ok, got: {:?}", result);
    }

    #[test]
    #[should_panic(expected = "out of bounds")]
    fn test_panic() {
        let v = vec![1, 2, 3];
        v[99];
    }

    #[test]
    fn result_test() -> Result<(), String> {
        let val = parse("42").map_err(|e| e.to_string())?;
        assert_eq!(val, 42);
        Ok(())
    }

    #[test]
    #[ignore]  // skipped unless: cargo test -- --ignored
    fn expensive_test() { /* ... */ }
}

// Integration tests: tests/ directory (separate compilation unit)
// Doc tests: code in /// comments is compiled and tested

25. Trait Objects & Dynamic Dispatch

Fat Pointers & VTable Layout

A trait object (&dyn Trait) is a fat pointer: 16 bytes on 64-bit systems (2 × 8-byte pointers).

// Structure of &dyn Trait:
// [data_ptr: *const T] [vtable_ptr: *const VTable]
//
// VTable contains function pointers for all trait methods:
// struct VTable {
//     drop_fn: unsafe fn(*mut T),
//     size: usize,
//     align: usize,
//     method_1: fn(*const T, ...) -> ReturnType,
//     method_2: fn(*const T, ...) -> ReturnType,
//     ...
// }

trait Animal {
    fn speak(&self) -> String;
    fn move_around(&mut self);
}

struct Dog;
impl Animal for Dog {
    fn speak(&self) -> String { "Woof!".to_string() }
    fn move_around(&mut self) {}
}

struct Cat;
impl Animal for Cat {
    fn speak(&self) -> String { "Meow!".to_string() }
    fn move_around(&mut self) {}
}

// Creating trait objects
let dog: Box<dyn Animal> = Box::new(Dog);
let cat: Box<dyn Animal> = Box::new(Cat);

// Both point to different data with different vtables
let animals: Vec<Box<dyn Animal>> = vec![
    Box::new(Dog),
    Box::new(Cat),
];

// Each Box contains: [heap_ptr to Dog/Cat] [vtable_ptr]
// When you call dog.speak(), the vtable is dereferenced to find the right function

&dyn Trait vs Box<dyn Trait>

// &dyn Trait — borrowed trait object (fat reference)
// Stores: [data_ptr: &T] [vtable_ptr: *const VTable]
fn print_animal(animal: &dyn Animal) {
    println!("{}", animal.speak());
}

// Box<dyn Trait> — owned trait object
// Stores: [data_ptr: *mut T] [vtable_ptr: *const VTable]
// Owns the data; drops it when Box is dropped
fn process(mut animal: Box<dyn Animal>) {
    animal.move_around();
    // animal is dropped here
}

// Other pointers to trait objects:
// Arc<dyn Trait> — thread-safe shared ownership
let shared: Arc<dyn Animal> = Arc::new(Dog);

// Rc<dyn Trait> — single-threaded shared ownership
let rc: Rc<dyn Animal> = Rc::new(Cat);

// Pattern: store trait objects in Vec
let mut menagerie: Vec<Box<dyn Animal>> = vec![];
menagerie.push(Box::new(Dog));
menagerie.push(Box::new(Cat));

for animal in &menagerie {
    println!("{}", animal.speak());
}
// Two different speak() implementations called via vtable dispatch

Object Safety Rules

Only traits with object-safe methods can become trait objects. A method is object-safe if:

// NOT object-safe — Self in return type
trait Cloneable {
    fn clone(&self) -> Self;  // ERROR: can't be trait object
}

// SAFE — returns concrete type
trait Drawable {
    fn draw(&self);  // OK
}

impl Drawable for Circle { fn draw(&self) {} }
let shape: Box<dyn Drawable> = Box::new(Circle);

// NOT object-safe — generic type parameter
trait Processor {
    fn process<T>(&self, input: T);  // ERROR
}

// SAFE — use associated type instead
trait Processor2 {
    type Input;
    fn process(&self, input: Self::Input);
}

// NOT object-safe — const generic
trait Batched {
    fn batch<const N: usize>(&self, items: [u8; N]);  // ERROR
}

// Checking object safety at compile time
const _: () = {
    fn assert_object_safe(_: &dyn Drawable) {}
};

Static vs Dynamic Dispatch Performance

// Static dispatch — compiler generates specialized code
fn process_static<T: Animal>(animal: &T) {
    println!("{}", animal.speak());
}
// Compiler generates:
// process_static<Dog>, process_static<Cat>, etc.

// Dynamic dispatch — single code path, runtime lookup
fn process_dynamic(animal: &dyn Animal) {
    println!("{}", animal.speak());
}
// One function; vtable lookup for the actual speak() implementation

// Benchmark: static vs dynamic
use std::time::Instant;

fn bench_static() {
    let animals: Vec<Box<dyn std::any::Any>> = vec![
        Box::new(Dog),
        Box::new(Cat),
    ];

    let start = Instant::now();
    for _ in 0..1_000_000 {
        for animal in &animals {
            // Would need type checking here; use process_static in real code
        }
    }
    println!("Static: {:?}", start.elapsed());
}

fn bench_dynamic() {
    let animals: Vec<Box<dyn Animal>> = vec![
        Box::new(Dog),
        Box::new(Cat),
    ];

    let start = Instant::now();
    for _ in 0..1_000_000 {
        for animal in &animals {
            let _ = animal.speak();  // vtable dispatch
        }
    }
    println!("Dynamic: {:?}", start.elapsed());
}
// Static typically 2-5x faster in tight loops
// Dynamic often fast enough if not in innermost loop

When to Use Each

impl Trait vs dyn Trait Decision Tree

// Decision tree examples:

// 1. Return different types from branches
fn factory(kind: &str) -> Box<dyn Animal> {
    match kind {
        "dog" => Box::new(Dog),
        "cat" => Box::new(Cat),
        _ => Box::new(Dog),
    }
}

// 2. Store multiple types in one collection
fn collect_animals(animals: Vec<Box<dyn Animal>>) {
    for animal in animals {
        println!("{}", animal.speak());
    }
}

// 3. Use generic if you need static dispatch
fn single_animal<T: Animal>(animal: &T) {
    println!("{}", animal.speak());
}
// Compiler generates monomorphic versions

Downcasting with Any

use std::any::Any;

trait Animal: Any {
    fn speak(&self) -> String;
}

struct Dog {
    breed: String,
}

impl Animal for Dog {
    fn speak(&self) -> String { "Woof!".to_string() }
}

impl Dog {
    fn fetch(&self) {
        println!("Fetching as a {}", self.breed);
    }
}

fn interact(animal: &dyn Animal) {
    println!("{}", animal.speak());

    // Downcast to Dog using type_id
    if let Some(dog) = (animal as &dyn Any).downcast_ref::<Dog>() {
        dog.fetch();
    }
}

// Usage
let dog = Dog { breed: "Labrador".to_string() };
interact(&dog);

// Downcasting Box<dyn Trait>
fn extract_dog(animal: Box<dyn Animal>) -> Option<Dog> {
    (animal as Box<dyn Any>)
        .downcast::<Dog>()
        .ok()
        .map(|boxed| *boxed)
}

// Mutable downcasting
fn train(animal: &mut dyn Animal) {
    if let Some(dog) = (animal as &mut dyn Any).downcast_mut::<Dog>() {
        dog.trained = true;
    }
}

26. Pin, Unpin & Self-Referential Types

Why Pin Exists

Self-referential structs and async await contexts require guaranteed memory stability. Pin ensures a value is never moved in memory after construction.

// Problem: Self-referential struct (NOT possible without Pin/unsafe)
struct SelfRef {
    value: String,
    // ptr_to_value: *const String,  // Would become dangling if moved!
}

// If you move this struct, the pointer becomes dangling.

// Solution: Async/await creates self-referential state machines
async fn example() {
    let s = "hello".to_string();
    some_future().await;  // May suspend; s must stay in same memory
    println!("{}", s);
}

// Generated state machine:
enum State {
    Start,
    WaitingForFuture {
        s: String,
        // Hidden: reference to `s` while suspended
    },
}

// Pin guarantees:
// - Value cannot be moved once pinned
// - Safe to create self-references if Drop is custom (unsafe code)
// - Required for async state machine guarantees

Pin<&T> Variants

use std::pin::Pin;
use std::marker::PhantomPinned;

// Basic Pin usage
let mut value = 5;
let pinned = Pin::new(&mut value);
// value cannot be moved; pinned.deref_mut() must be used for mutable access

// Pin with Box (heap-allocated, stable address)
let boxed = Box::new(String::from("hello"));
let pinned_box: Pin<Box<String>> = Pin::new(boxed);
// String is on heap, will never move

// Self-referential struct with PhantomPinned
struct Node {
    data: i32,
    next: Option<Pin<Box<Node>>>,
    // PhantomPinned prevents impl of Unpin
    _pin: PhantomPinned,
}

// Can only create self-ref with manual Pin construction
let mut node = Box::pin(Node {
    data: 42,
    next: None,
    _pin: PhantomPinned,
});

// Now node.next can safely hold a Pin to self once initialized

Unpin Marker Trait

Most types implement Unpin (marker trait, auto-derived). A type is Unpin if it's safe to move it after pinning. Only types with self-references or custom drop logic need !Unpin.

use std::marker::{PhantomPinned, Unpin};

// Most types are Unpin
struct Normal {
    x: i32,
    y: String,
}
// impl Unpin for Normal {}  // Auto-derived; can be moved safely

// Types that prevent Unpin
struct NotUnpin {
    value: String,
    _pin: PhantomPinned,  // Makes !Unpin
}
// NOT impl Unpin for NotUnpin

// Only Unpin types can be moved out of Pin
fn move_if_unpin<T: Unpin>(pinned: Pin<&mut T>) -> T {
    // Can only work for Unpin types
    *Pin::into_inner(pinned)
}

// Non-Unpin types can't be moved, but can be mutated in place
fn mutate_pinned<T: ?Sized>(pinned: Pin<&mut T>) {
    // Can access with Pin::get_unchecked_mut only if you promise safety
    let r = unsafe { Pin::get_unchecked_mut(pinned) };
    // Now you have &mut T but T hasn't moved!
}

// Custom impl !Unpin
struct CustomNotUnpin {
    data: Vec<i32>,
}
impl !Unpin for CustomNotUnpin {}  // nightly feature

pin_project Macro

use pin_project::pin_project;
use std::pin::Pin;

// Derives Pin projection for fields
#[pin_project]
struct MyStruct {
    #[pin]
    pinned_field: String,
    regular_field: i32,
}

impl MyStruct {
    fn do_something(self: Pin<&mut Self>) {
        let this = self.project();

        // this.pinned_field is Pin<&mut String>
        let pinned_str: Pin<&mut String> = this.pinned_field;

        // this.regular_field is &mut i32
        let normal: &mut i32 = this.regular_field;
    }
}

// Use in streams/futures
#[pin_project]
struct BufferedReader<R> {
    #[pin]
    reader: R,
    buffer: Vec<u8>,
}

// pin_project generates safe projections automatically
// Prevents accidental moving of pinned fields

Manual Pin Implementation

use std::pin::Pin;
use std::marker::PhantomPinned;
use std::ops::{Deref, DerefMut};

// Manually implement Pin safety for a custom type
struct SelfRefStruct {
    name: String,
    name_ptr: *const String,  // Points to self.name
    _pin: PhantomPinned,
}

impl SelfRefStruct {
    fn new(name: String) -> Pin<Box<Self>> {
        let mut boxed = Box::new(SelfRefStruct {
            name,
            name_ptr: std::ptr::null(),
            _pin: PhantomPinned,
        });

        let name_ptr = &boxed.name as *const String;
        unsafe {
            boxed.name_ptr = name_ptr;
        }

        Pin::new(boxed)
    }

    fn get_name(&self) -> &str {
        // Safe: name_ptr is valid because struct is pinned
        unsafe { &*self.name_ptr }
    }
}

// Custom Drop for pinned types
impl Drop for SelfRefStruct {
    fn drop(&mut self) {
        // Safe to access self because Pin guarantees stability
        let _ = self.get_name();
    }
}

// Usage
fn main() {
    let pinned = SelfRefStruct::new("hello".to_string());
    println!("{}", pinned.get_name());
}

Structural Pinning Rules

use std::pin::Pin;

// Structural pinning: projection respects Pin semantics
struct Structural {
    field: String,
}

impl Structural {
    // Safe projection: field doesn't have internal references
    fn project(self: Pin<&mut Self>) -> Pin<&mut String> {
        unsafe { Pin::new_unchecked(&mut self.get_unchecked_mut().field) }
    }
}

// Intrinsic pinning: type requires Pin regardless
struct Intrinsic {
    _pin: std::marker::PhantomPinned,
}

// Non-structural (WRONG): projecting a self-referential field
struct BadStructural {
    data: String,
    ptr: *const String,  // Points to data!
}

impl BadStructural {
    fn project_bad(self: Pin<&mut Self>) -> Pin<&mut String> {
        // WRONG: moving data would invalidate ptr!
        // Never do this without deep understanding
        unsafe { Pin::new_unchecked(&mut self.get_unchecked_mut().data) }
    }
}

// Rule: only project fields that don't reference other struct fields

Pin in async/await Context

use std::future::Future;
use std::pin::Pin;
use std::task::{Context, Poll};

// Futures must be pinned before polling
async fn my_async() -> i32 {
    42
}

fn use_future() {
    let future = my_async();
    let mut boxed = Box::pin(future);

    // Can poll a pinned future
    // In real code, the executor does this
}

// Manual Future impl requires Pin
struct MyFuture {
    state: u32,
}

impl Future for MyFuture {
    type Output = i32;

    fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<i32> {
        // self: Pin<&mut Self> guarantees stable memory
        // Can create self-references safely during suspension
        Poll::Ready(42)
    }
}

// Async state machine created by async/await:
enum AsyncState {
    Start,
    Waiting {
        variable: String,
        // reference: &String,  // Safe because state pinned
    },
    Done,
}

// Each .await point creates a state that can hold references
// Pin guarantees references remain valid across await

27. FFI (Foreign Function Interface)

Calling C from Rust

// Declaring C functions
extern "C" {
    fn printf(format: *const u8, ...) -> i32;
    fn strlen(s: *const u8) -> usize;
    fn malloc(size: usize) -> *mut u8;
    fn free(ptr: *mut u8);
}

// Safe wrapper
unsafe fn print_c_string(s: *const u8) {
    printf(b"String: %s\n\0".as_ptr() as *const u8, s);
}

// Calling C function
fn main() {
    unsafe {
        let c_str = b"Hello from Rust\0";
        print_c_string(c_str.as_ptr());
    }
}

// Better: use std::ffi for C string conversion
use std::ffi::{CStr, CString};

fn safe_strlen(s: &CStr) -> usize {
    unsafe { strlen(s.as_ptr() as *const u8) }
}

fn main() {
    let rust_str = "hello";
    let c_str = CString::new(rust_str).unwrap();
    let len = safe_strlen(&c_str);
    println!("Length: {}", len);
}

Calling Rust from C

// Rust code that C will call
#[no_mangle]
pub extern "C" fn add(a: i32, b: i32) -> i32 {
    a + b
}

#[no_mangle]
pub extern "C" fn process_string(s: *const u8) -> i32 {
    if s.is_null() {
        return -1;
    }

    unsafe {
        let len = libc::strlen(s);
        len as i32
    }
}

// In C:
// extern int add(int a, int b);
// int result = add(5, 3);  // 8
//
// extern int process_string(const char *s);
// int len = process_string("hello");  // 5

// Build as a library
// Cargo.toml:
// [lib]
// crate-type = ["cdylib"]  // C-compatible dynamic library
// or
// crate-type = ["staticlib"]  // Static library

extern "C" & #[no_mangle]

// Without #[no_mangle], Rust mangles the name
pub extern "C" fn process() {}
// Mangled: _ZN7example7processE (or similar)
// C can't find "process"

// With #[no_mangle], name is exposed as-is
#[no_mangle]
pub extern "C" fn process() {}
// Symbol: process
// C can now link and call it

// Multiple ABIs
extern "C" { fn c_func(); }          // C calling convention
extern "cdecl" { fn cdecl_func(); }  // C declaration (Windows)
extern "stdcall" { fn stdcall_func(); }  // Windows API
extern "fastcall" { fn fast_func(); } // Fast call (Windows)

// Using #[no_mangle] for exported Rust functions
#[no_mangle]
pub extern "C" fn rust_malloc(size: usize) -> *mut u8 {
    let vec: Vec<u8> = vec![0; size];
    Box::into_raw(vec.into_boxed_slice()) as *mut u8
}

#[no_mangle]
pub extern "C" fn rust_free(ptr: *mut u8, size: usize) {
    if !ptr.is_null() {
        unsafe {
            let _ = Vec::from_raw_parts(ptr, 0, size);
        }
    }
}

CString & CStr — C String Conversion

use std::ffi::{CStr, CString};
use std::os::raw::c_char;

// CString: owned C string (null-terminated)
let rust_str = "Hello, World!";
let c_string = CString::new(rust_str).unwrap();
// Automatically adds null terminator

// Get pointer to pass to C
let ptr: *const c_char = c_string.as_ptr();

// CStr: borrowed C string (immutable)
unsafe fn from_c_str(ptr: *const c_char) -> &'static str {
    let c_str = CStr::from_ptr(ptr);
    c_str.to_str().unwrap()
}

// Roundtrip conversion
fn main() {
    let original = "rust string";
    let c_string = CString::new(original).unwrap();
    let c_str = CStr::from_bytes_with_nul(b"rust string\0").unwrap();

    assert_eq!(original, c_str.to_str().unwrap());
}

// Handling embedded nulls
let with_null = "string\0with\0nulls";
match CString::new(with_null) {
    Ok(_) => println!("No embedded nulls"),
    Err(e) => println!("Contains null: {}", e),
}

// Safe wrapper for C function taking &CStr
extern "C" {
    fn c_strlen(s: *const c_char) -> usize;
}

fn safe_strlen(s: &str) -> usize {
    let c_str = CString::new(s).unwrap();
    unsafe { c_strlen(c_str.as_ptr()) }
}

Raw Pointers in FFI

use std::ptr;

// Creating null pointers
let null: *const i32 = ptr::null();
let null_mut: *mut i32 = ptr::null_mut();

// Dereferencing raw pointers (unsafe)
let x = 42;
let ptr: *const i32 = &x;
unsafe {
    println!("{}", *ptr);  // 42
}

// Pointer arithmetic
fn buffer_access(ptr: *const i32, index: usize) -> i32 {
    unsafe { *ptr.add(index) }
}

// Pointer casts
let ptr: *const u8 = b"hello".as_ptr();
let as_int = ptr as *const i32;  // Reinterpret as i32

// Offset calculations
fn struct_field_offset() {
    #[repr(C)]
    struct MyStruct {
        a: i32,
        b: i64,
    }

    let ptr = &MyStruct { a: 1, b: 2 } as *const MyStruct;

    unsafe {
        // Get address of field 'b'
        let b_ptr = &(*ptr).b as *const i64;
        // or using offset:
        let b_offset = ptr.cast::<i64>().offset(1);
    }
}

// Volatile reads/writes (for memory-mapped I/O)
unsafe fn read_volatile_register(addr: *const u32) -> u32 {
    ptr::read_volatile(addr)
}

unsafe fn write_volatile_register(addr: *mut u32, value: u32) {
    ptr::write_volatile(addr, value);
}

bindgen & cbindgen Tools

// bindgen — auto-generate Rust bindings from C headers
// Cargo.toml:
// [build-dependencies]
// bindgen = "0.68"

// build.rs:
use bindgen;

fn main() {
    let bindings = bindgen::Builder::default()
        .header("wrapper.h")
        .generate()
        .expect("Unable to generate bindings");

    bindings.write_to_file("src/bindings.rs")
        .expect("Couldn't write bindings!");
}

// Generates Rust code like:
// extern "C" {
//     pub fn c_function(a: i32, b: i32) -> i32;
// }

// cbindgen — auto-generate C bindings from Rust code
// Cargo.toml:
// [package.metadata.cbindgen]
// language = "C"
// [lib]
// crate_type = ["cdylib", "staticlib"]

// rust_lib.rs:
#[no_mangle]
pub extern "C" fn add(a: i32, b: i32) -> i32 {
    a + b
}

#[no_mangle]
pub extern "C" fn process(ptr: *mut i32) {
    unsafe { *ptr += 1; }
}

// cbindgen generates:
// int32_t add(int32_t a, int32_t b);
// void process(int32_t *ptr);

Safety Wrappers

use std::ffi::{CStr, CString};
use std::ptr;

// Unsafe C function
extern "C" {
    fn unsafe_c_func(ptr: *const u8, len: usize) -> i32;
}

// Safe wrapper
pub fn safe_wrapper(data: &[u8]) -> i32 {
    unsafe {
        unsafe_c_func(data.as_ptr(), data.len())
    }
}

// Wrapper with error handling
pub fn wrapper_with_error(data: &str) -> Result<i32, &'static str> {
    let c_str = CString::new(data).map_err(|_| "contains null byte")?;

    let result = unsafe { unsafe_c_func(c_str.as_ptr() as *const u8, data.len()) };

    match result {
        0 => Ok(0),
        -1 => Err("function failed"),
        _ => Ok(result),
    }
}

// Allocation wrapper
extern "C" {
    fn c_malloc(size: usize) -> *mut u8;
    fn c_free(ptr: *mut u8);
}

pub struct MallocBuffer(*mut u8, usize);

impl MallocBuffer {
    pub fn new(size: usize) -> Option<Self> {
        let ptr = unsafe { c_malloc(size) };
        if ptr.is_null() {
            None
        } else {
            Some(MallocBuffer(ptr, size))
        }
    }

    pub fn as_slice(&self) -> &[u8] {
        unsafe { std::slice::from_raw_parts(self.0, self.1) }
    }

    pub fn as_mut_slice(&mut self) -> &mut [u8] {
        unsafe { std::slice::from_raw_parts_mut(self.0, self.1) }
    }
}

impl Drop for MallocBuffer {
    fn drop(&mut self) {
        unsafe { c_free(self.0); }
    }
}

repr(C) Layout

// repr(Rust) — Rust's optimized layout (default)
struct RustLayout {
    a: u8,    // 1 byte
    b: u64,   // 8 bytes
    c: u32,   // 4 bytes
}
// Rust reorders for cache alignment:
// [b: u64, c: u32, a: u8] (12 bytes + 3 padding)

// repr(C) — C-compatible layout (sequential)
#[repr(C)]
struct CLayout {
    a: u8,    // 1 byte
    b: u64,   // 7 bytes padding + 8 bytes
    c: u32,   // 4 bytes
}
// Exact order: [a: u8, padding: 7, b: u64, c: u32] (20 bytes)

// repr(transparent) — single field with same layout
#[repr(transparent)]
struct Wrapper(String);
// Wrapper has same layout as String (can transmute safely)

// Using repr(C) with FFI
extern "C" {
    fn c_struct_process(data: *const CLayout);
}

fn main() {
    let layout = CLayout { a: 1, b: 2, c: 3 };
    unsafe {
        c_struct_process(&layout);
    }
}

// Checking layout with std::mem
use std::mem;

fn main() {
    println!("Size: {}", mem::size_of::<CLayout>());
    println!("Align: {}", mem::align_of::<CLayout>());
    println!("Offset of b: {}", unsafe {
        &(*(ptr::null::<CLayout>())).b as *const _ as usize
    });
}

28. Custom Allocators & Memory

Global Allocator Trait

use std::alloc::{GlobalAlloc, Layout};
use std::ptr::NonNull;

// The GlobalAlloc trait
pub unsafe trait GlobalAlloc {
    unsafe fn alloc(&self, layout: Layout) -> *mut u8;
    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout);

    // Optional overrides
    unsafe fn realloc(
        &self,
        ptr: *mut u8,
        old_layout: Layout,
        new_layout: Layout,
    ) -> *mut u8 {
        // Default: alloc + copy + dealloc
        let new_ptr = self.alloc(new_layout);
        if !new_ptr.is_null() {
            std::ptr::copy_nonoverlapping(
                ptr,
                new_ptr,
                old_layout.size().min(new_layout.size()),
            );
            self.dealloc(ptr, old_layout);
        }
        new_ptr
    }

    unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {
        let ptr = self.alloc(layout);
        if !ptr.is_null() {
            std::ptr::write_bytes(ptr, 0, layout.size());
        }
        ptr
    }
}

// Simple counting allocator
struct CountingAllocator;

unsafe impl GlobalAlloc for CountingAllocator {
    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
        let ret = std::alloc::System.alloc(layout);
        if !ret.is_null() {
            eprintln!("Allocated {} bytes", layout.size());
        }
        ret
    }

    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
        std::alloc::System.dealloc(ptr, layout);
        eprintln!("Deallocated {} bytes", layout.size());
    }
}

// Set the global allocator
#[global_allocator]
static GLOBAL: CountingAllocator = CountingAllocator;

jemalloc & mimalloc Integration

// Using jemalloc — efficient memory allocator
// Cargo.toml:
// [dependencies]
// jemallocator = "0.5"

use jemallocator::Jemalloc;

#[global_allocator]
static GLOBAL: Jemalloc = Jemalloc;

fn main() {
    let _v = vec![1, 2, 3];
    // Allocated with jemalloc instead of System allocator
}

// Using mimalloc — Microsoft's fast allocator
// Cargo.toml:
// [dependencies]
// mimalloc = "0.1"

use mimalloc::MiMalloc;

#[global_allocator]
static GLOBAL: MiMalloc = MiMalloc;

fn main() {
    let _v = vec![1, 2, 3];
    // Allocated with mimalloc
}

// Measuring allocator performance
fn bench_allocator() {
    use std::time::Instant;

    let start = Instant::now();
    let mut vecs = Vec::new();

    for _ in 0..10000 {
        vecs.push(vec![0u8; 1024]);
    }

    println!("Time: {:?}", start.elapsed());
}

// jemalloc and mimalloc are generally faster than System
// for fragmentation-heavy workloads

Arena Allocators (bumpalo)

use bumpalo::Bump;

// Arena allocator — allocate many objects, free all at once
fn process_with_arena() {
    let arena = Bump::new();

    // All allocations use the arena
    let vec = arena.alloc(vec![1, 2, 3]);
    let string = arena.alloc(String::from("hello"));
    let boxed = arena.alloc(42i32);

    println!("{:?}", vec);
    println!("{}", string);
    println!("{}", boxed);

    // When arena goes out of scope, all allocations freed at once
    // No individual drop() calls
}

// Useful for temporary allocations in tight loops
fn parse_many_strings(input: &str) -> Vec<String> {
    let arena = Bump::new();

    input
        .lines()
        .map(|line| {
            let processed = arena.alloc(line.to_uppercase());
            processed.clone()  // Clone to escape arena lifetime
        })
        .collect()
}

// Custom struct with arena allocation
struct Parser<'a> {
    arena: &'a Bump,
}

impl<'a> Parser<'a> {
    fn new(arena: &'a Bump) -> Self {
        Parser { arena }
    }

    fn allocate_string(&self, s: &str) -> &'a mut String {
        self.arena.alloc(String::from(s))
    }
}

fn main() {
    let arena = Bump::new();
    let parser = Parser::new(&arena);

    let s = parser.allocate_string("hello");
    s.push_str(" world");
    println!("{}", s);
}

Memory Layout: Size, Align, Padding

use std::mem::{size_of, align_of};
use std::ptr;

// Basic layout
struct Simple {
    a: u32,  // 4 bytes, align 4
    b: u8,   // 1 byte, align 1
}

fn analyze_layout() {
    println!("Size: {}", size_of::<Simple>());      // 8 (not 5!)
    println!("Align: {}", align_of::<Simple>());    // 4
    // Rust pads with 3 bytes between a and b for alignment
}

// Layout with explicit repr(C)
#[repr(C)]
struct CStyle {
    a: u32,   // offset 0, size 4
    b: u8,    // offset 4, size 1
    c: u64,   // offset 12 (8-byte align), size 8
}

fn c_layout() {
    println!("Size: {}", size_of::<CStyle>());  // 24
    // Padding:
    // [a: 4 bytes] [padding: 4] [b: 1 byte] [padding: 7] [c: 8 bytes]
}

// Reordered for efficiency
struct Reordered {
    a: u64,   // 8 bytes, align 8
    b: u32,   // 4 bytes, align 4
    c: u8,    // 1 byte, align 1
}

fn optimal_layout() {
    println!("Size: {}", size_of::<Reordered>());  // 16 (not 13)
    // Rust reorders to: [a: u64] [b: u32] [c: u8, padding: 3]
}

// Calculating field offsets
fn field_offsets() {
    #[repr(C)]
    struct Data {
        a: u32,
        b: u64,
        c: u32,
    }

    let base = &Data { a: 1, b: 2, c: 3 } as *const Data as usize;

    let a_offset = &(*ptr::null::<Data>()).a as *const _ as usize;
    let b_offset = &(*ptr::null::<Data>()).b as *const _ as usize;
    let c_offset = &(*ptr::null::<Data>()).c as *const _ as usize;

    println!("a at: {}", a_offset);
    println!("b at: {}", b_offset);
    println!("c at: {}", c_offset);
}

// Zero-sized types (ZST)
struct ZeroSized;

fn zst_info() {
    println!("Size: {}", size_of::<ZeroSized>());  // 0
    println!("Align: {}", align_of::<ZeroSized>());  // 1
}

// Array padding
struct Array {
    items: [u64; 3],  // 24 bytes, align 8
}

// Nested struct padding
struct Nested {
    a: u32,
    inner: Simple,  // align 4, so 0 padding before it
}

alloc::Layout

use std::alloc::Layout;
use std::ptr::NonNull;

// Creating layouts
fn create_layouts() {
    // For a single type
    let layout = Layout::new::<u32>();
    println!("u32: size {}, align {}", layout.size(), layout.align());

    // For an array
    let array_layout = Layout::new::<[u32; 10]>();
    println!("Array: size {}, align {}", array_layout.size(), array_layout.align());

    // Manual layout
    let manual = Layout::from_size_align(16, 8).unwrap();
    println!("Manual: size {}, align {}", manual.size(), manual.align());

    // Extend a layout (for flexible array members)
    let base = Layout::new::<u32>();
    let (extended, _offset) = base.extend(Layout::new::<u8>()).unwrap();
    println!("Extended: size {}", extended.size());
}

// Allocating with Layout
fn allocate_with_layout() {
    let layout = Layout::new::<[u64; 10]>();

    let ptr = unsafe {
        std::alloc::alloc(layout) as *mut u64
    };

    if ptr.is_null() {
        panic!("allocation failed");
    }

    unsafe {
        // Initialize
        for i in 0..10 {
            *ptr.add(i) = i as u64;
        }

        // Use
        println!("{}", *ptr.add(5));

        // Deallocate
        std::alloc::dealloc(ptr as *mut u8, layout);
    }
}

// Layout for variadic structs
fn flexible_array() {
    #[repr(C)]
    struct Header {
        id: u32,
        count: u32,
    }

    fn allocate_with_data(count: usize) -> *mut Header {
        let header_layout = Layout::new::<Header>();
        let data_layout = Layout::array::<u64>(count).unwrap();
        let (layout, offset) = header_layout.extend(data_layout).unwrap();

        let ptr = unsafe { std::alloc::alloc(layout) as *mut Header };

        unsafe {
            (*ptr).id = 1;
            (*ptr).count = count as u32;
            // Data starts at ptr + offset
            let data = (ptr as *mut u8).add(offset) as *mut u64;
            for i in 0..count {
                *data.add(i) = i as u64;
            }
        }

        ptr
    }
}

Custom Collections with Allocators

use std::alloc::{GlobalAlloc, Layout};
use std::ptr::NonNull;

// Custom vector-like collection using a specific allocator
struct CustomVec<T, A: GlobalAlloc> {
    ptr: NonNull<T>,
    capacity: usize,
    len: usize,
    allocator: A,
}

impl<T, A: GlobalAlloc> CustomVec<T, A> {
    fn new(allocator: A) -> Self {
        CustomVec {
            ptr: NonNull::dangling(),
            capacity: 0,
            len: 0,
            allocator,
        }
    }

    fn push(&mut self, value: T) {
        if self.len == self.capacity {
            self.grow();
        }

        unsafe {
            let ptr = self.ptr.as_mut() as *mut T;
            std::ptr::write(ptr.add(self.len), value);
        }
        self.len += 1;
    }

    fn grow(&mut self) {
        let new_capacity = if self.capacity == 0 { 1 } else { self.capacity * 2 };

        let new_layout = Layout::array::<T>(new_capacity).unwrap();
        let new_ptr = if self.capacity == 0 {
            unsafe { self.allocator.alloc(new_layout) }
        } else {
            let old_layout = Layout::array::<T>(self.capacity).unwrap();
            unsafe {
                self.allocator.realloc(
                    self.ptr.as_mut() as *mut u8,
                    old_layout,
                    new_layout,
                )
            }
        };

        self.ptr = NonNull::new(new_ptr as *mut T).expect("allocation failed");
        self.capacity = new_capacity;
    }

    fn pop(&mut self) -> Option<T> {
        if self.len == 0 {
            None
        } else {
            self.len -= 1;
            unsafe { Some(std::ptr::read(self.ptr.as_ptr().add(self.len))) }
        }
    }
}

impl<T, A: GlobalAlloc> Drop for CustomVec<T, A> {
    fn drop(&mut self) {
        if self.capacity != 0 {
            unsafe {
                for i in 0..self.len {
                    std::ptr::drop_in_place(self.ptr.as_ptr().add(i));
                }
                let layout = Layout::array::<T>(self.capacity).unwrap();
                self.allocator.dealloc(self.ptr.as_mut() as *mut u8, layout);
            }
        }
    }
}

Zero-Copy Patterns

use std::mem;

// Pattern 1: Direct buffer reinterpretation
fn bytes_to_u32s(bytes: &[u8]) -> &[u32] {
    assert_eq!(bytes.len() % 4, 0);
    assert_eq!(bytes.as_ptr() as usize % 4, 0);  // Check alignment

    unsafe {
        std::slice::from_raw_parts(
            bytes.as_ptr() as *const u32,
            bytes.len() / 4,
        )
    }
}

// Pattern 2: Transmute for layout-compatible types
#[repr(C)]
struct Bytes4 {
    a: u8,
    b: u8,
    c: u8,
    d: u8,
}

#[repr(transparent)]
struct U32Wrapper(u32);

fn transmute_zero_copy(b: Bytes4) -> U32Wrapper {
    unsafe { mem::transmute(b) }
}

// Pattern 3: mmap files as structures
fn load_from_file() {
    // In real code, use memmap crate
    // let mmap = Mmap::open("file.bin").unwrap();
    // let data: &[Header] = unsafe {
    //     std::slice::from_raw_parts(
    //         mmap.as_ptr() as *const Header,
    //         mmap.len() / size_of::<Header>(),
    //     )
    // };
}

// Pattern 4: Endian-aware zero-copy reading
fn read_u32_le(bytes: &[u8]) -> u32 {
    let mut buf = [0u8; 4];
    buf.copy_from_slice(&bytes[..4]);
    u32::from_le_bytes(buf)
}

// Pattern 5: Reference casting without copy
struct NetworkPacket {
    data: [u8; 100],
}

fn parse_packet(packet: &NetworkPacket) {
    let header: &[u8; 4] = unsafe {
        &*(packet.data.as_ptr() as *const [u8; 4])
    };
    println!("Header: {:?}", header);
}

29. SIMD & Inline Assembly

std::arch Intrinsics

// SIMD using x86 intrinsics
#[cfg(target_arch = "x86_64")]
use std::arch::x86_64::*;

#[cfg(target_arch = "x86_64")]
fn simd_add_i32() {
    unsafe {
        // Create SIMD vectors
        let a = _mm_setr_epi32(1, 2, 3, 4);
        let b = _mm_setr_epi32(5, 6, 7, 8);

        // Add all 4 i32s in parallel
        let c = _mm_add_epi32(a, b);

        // Extract results
        let result = [
            _mm_extract_epi32::<0>(c),
            _mm_extract_epi32::<1>(c),
            _mm_extract_epi32::<2>(c),
            _mm_extract_epi32::<3>(c),
        ];
        println!("{:?}", result);  // [6, 8, 10, 12]
    }
}

// Floating point SIMD
#[cfg(target_arch = "x86_64")]
fn simd_multiply_f32() {
    unsafe {
        let a = _mm_setr_ps(1.0, 2.0, 3.0, 4.0);
        let b = _mm_setr_ps(2.0, 2.0, 2.0, 2.0);
        let c = _mm_mul_ps(a, b);

        println!("{:?}", [
            _mm_cvtss_f32(c),
            _mm_cvtss_f32(_mm_shuffle_ps::<0b01010101>(c, c)),
        ]);
    }
}

// SIMD memory operations (SSE4.2)
#[cfg(all(target_arch = "x86_64", target_feature = "sse4.2"))]
fn simd_memcpy(src: &[u8], dst: &mut [u8]) {
    unsafe {
        for i in (0..src.len()).step_by(16) {
            let data = _mm_loadu_si128(src.as_ptr().add(i) as *const __m128i);
            _mm_storeu_si128(dst.as_mut_ptr().add(i) as *mut __m128i, data);
        }
    }
}

Portable SIMD (std::simd — Nightly)

#![feature(portable_simd)]

use std::simd::{Simd, SimdInt, SimdFloat};

fn portable_simd_add() {
    // Create SIMD vectors portable across architectures
    let a: Simd<i32, 4> = Simd::from_array([1, 2, 3, 4]);
    let b: Simd<i32, 4> = Simd::from_array([5, 6, 7, 8]);

    let c = a + b;

    println!("{:?}", c.to_array());  // [6, 8, 10, 12]
}

fn portable_simd_float() {
    let a: Simd<f32, 4> = Simd::from_array([1.0, 2.0, 3.0, 4.0]);
    let b: Simd<f32, 4> = Simd::from_array([0.1, 0.2, 0.3, 0.4]);

    let c = a + b;
    let d = a.abs();
    let e = a.sqrt();

    println!("Add: {:?}", c.to_array());
    println!("Abs: {:?}", d.to_array());
    println!("Sqrt: {:?}", e.to_array());
}

fn simd_reduction() {
    let v: Simd<i32, 4> = Simd::from_array([1, 2, 3, 4]);

    let sum = v.reduce_sum();  // 10
    let max = v.reduce_max();  // 4
    let min = v.reduce_min();  // 1

    println!("Sum: {}, Max: {}, Min: {}", sum, max, min);
}

fn simd_comparison() {
    let a: Simd<i32, 4> = Simd::from_array([1, 2, 3, 4]);
    let b: Simd<i32, 4> = Simd::from_array([2, 2, 2, 2]);

    let mask = a.simd_lt(b);  // Element-wise <
    // mask represents: [true, false, false, false]
}

#[target_feature] & CPU Feature Detection

// Function requiring specific CPU feature
#[target_feature(enable = "avx2")]
unsafe fn avx2_sum(v: &[f32]) -> f32 {
    use std::arch::x86_64::*;

    let mut sum = _mm256_setzero_ps();

    for chunk in v.chunks_exact(8) {
        let data = _mm256_loadu_ps(chunk.as_ptr());
        sum = _mm256_add_ps(sum, data);
    }

    // Horizontal reduction
    let result = _mm256_extractf128_ps::<1>(sum);
    _mm_cvtss_f32(_mm_hadd_ps(result, result))
}

// Runtime detection
fn main() {
    #[cfg(target_arch = "x86_64")]
    {
        if std::arch::x86_64::has_cpuid() {
            // Detect features at runtime
            if std::is_x86_feature_detected!("avx2") {
                let sum = unsafe { avx2_sum(&[1.0; 16]) };
                println!("AVX2 sum: {}", sum);
            } else {
                println!("AVX2 not supported");
            }
        }
    }
}

// Compile-time features
// Cargo.toml:
// [profile.release]
// rustflags = ["-C", "target-feature=+avx2"]

// Check at compile time
#[cfg(target_feature = "avx2")]
fn avx2_enabled() {
    println!("Compiled with AVX2");
}

#[cfg(not(target_feature = "avx2"))]
fn avx2_disabled() {
    println!("No AVX2");
}

asm! Macro for Inline Assembly

// Basic inline assembly
fn add_asm(a: i32, b: i32) -> i32 {
    let result: i32;

    unsafe {
        asm!(
            "add {}, {}",
            inout(reg) a => result,
            in(reg) b,
        );
    }

    result
}

// Memory-mapped I/O
unsafe fn read_register(addr: *const u32) -> u32 {
    let value: u32;

    asm!(
        "mov {}, [{}]",
        out(reg) value,
        in(reg) addr,
    );

    value
}

unsafe fn write_register(addr: *mut u32, value: u32) {
    asm!(
        "mov [{}], {}",
        in(reg) addr,
        in(reg) value,
    );
}

// Clobbering registers
fn cpu_id() -> u32 {
    let eax: u32;
    let ebx: u32;
    let ecx: u32;
    let edx: u32;

    unsafe {
        asm!(
            "cpuid",
            inout("eax") 1u32 => eax,
            out("ebx") ebx,
            out("ecx") ecx,
            out("edx") edx,
        );
    }

    eax
}

// Inline assembly with options
fn barrier() {
    unsafe {
        asm!(
            "mfence",
            options(nomem, nostack),
        );
    }
}

// Volatile assembly (always emitted)
fn spinloop() {
    unsafe {
        asm!(
            "jmp {0}",
            in(label) loop_label,
            options(noreturn),
        );

        loop_label:
        unreachable!();
    }
}

Performance Examples

use std::time::Instant;

// SIMD vs scalar loop
fn scalar_sum(data: &[f32]) -> f32 {
    data.iter().sum()
}

#[cfg(target_arch = "x86_64")]
#[target_feature(enable = "avx2")]
unsafe fn simd_sum(data: &[f32]) -> f32 {
    use std::arch::x86_64::*;

    let mut sum = _mm256_setzero_ps();

    for chunk in data.chunks_exact(8) {
        let v = _mm256_loadu_ps(chunk.as_ptr());
        sum = _mm256_add_ps(sum, v);
    }

    // Horizontal sum
    let mut arr = [0.0f32; 8];
    _mm256_storeu_ps(arr.as_mut_ptr(), sum);
    arr.iter().sum()
}

fn bench() {
    let data: Vec<f32> = (0..10_000).map(|i| i as f32).collect();

    let start = Instant::now();
    let scalar = scalar_sum(&data);
    let scalar_time = start.elapsed();

    #[cfg(target_arch = "x86_64")]
    {
        if is_x86_feature_detected!("avx2") {
            let start = Instant::now();
            let simd = unsafe { simd_sum(&data) };
            let simd_time = start.elapsed();

            println!("Scalar: {:?}, SIMD: {:?}", scalar_time, simd_time);
            println!("Speedup: {:.2}x", scalar_time.as_nanos() as f32 / simd_time.as_nanos() as f32);
        }
    }
}

30. Cargo & Build System Deep Dive

Cargo.toml Anatomy

[package]
name = "my_project"
version = "0.1.0"
edition = "2021"
authors = ["You"]
description = "A great library"
license = "MIT"
repository = "https://github.com/user/repo"
homepage = "https://example.com"
documentation = "https://docs.rs/my_project"
keywords = ["parsing", "cli"]
categories = ["command-line-utilities"]
readme = "README.md"
rust-version = "1.70"  # MSRV

[lib]
name = "my_lib"
path = "src/lib.rs"
crate-type = ["rlib"]  # or "cdylib", "staticlib", "dylib"

[[bin]]
name = "my_cli"
path = "src/main.rs"
required-features = ["cli"]

[dependencies]
serde = "1.0"
tokio = { version = "1.0", features = ["full"] }
my_crate = { path = "../my_crate" }
git_crate = { git = "https://github.com/user/repo", branch = "main" }

[dev-dependencies]
criterion = "0.5"
proptest = "1.0"

[build-dependencies]
bindgen = "0.69"

[target.'cfg(unix)'.dependencies]
libc = "0.2"

[target.'cfg(windows)'.dependencies]
windows = "0.52"

[features]
default = ["cli", "serde"]
cli = ["clap"]
performance = ["simd"]
serde = ["dep:serde"]
serde-support = ["serde"]  # Feature dependency

[profile.release]
opt-level = 3
lto = true
codegen-units = 1
strip = true

[profile.bench]
inherits = "release"
debug = true

[package.metadata.cargo-binstall]
pkg-url = "https://example.com/{name}-{version}.tar.gz"

Features & Conditional Compilation

// In Cargo.toml:
[features]
default = ["networking"]
networking = []
logging = ["tracing"]
compression = ["flate2"]
all-features = ["networking", "logging", "compression"]

// In code:
#[cfg(feature = "networking")]
mod network {
    pub fn connect() {
        println!("Connecting...");
    }
}

#[cfg(feature = "logging")]
fn log(msg: &str) {
    println!("{}", msg);
}

#[cfg(not(feature = "logging"))]
fn log(_msg: &str) {}

// Feature combination logic
#[cfg(all(feature = "networking", feature = "logging"))]
fn setup() {
    log("Setting up network...");
}

#[cfg(any(feature = "compression", feature = "async"))]
async fn compress_or_process() {}

// Build with features:
// cargo build --features "networking,logging"
// cargo build --all-features
// cargo build --no-default-features
// cargo build --no-default-features --features "logging"

cfg Attributes

// Platform-specific code
#[cfg(unix)]
fn get_home_dir() -> String {
    std::env::var("HOME").unwrap()
}

#[cfg(windows)]
fn get_home_dir() -> String {
    std::env::var("USERPROFILE").unwrap()
}

// Debug vs release
#[cfg(debug_assertions)]
fn expensive_check(x: i32) -> bool {
    println!("Checking {}", x);
    x > 0
}

#[cfg(not(debug_assertions))]
fn expensive_check(x: i32) -> bool {
    x > 0  // Optimized away in release
}

// Test-only code
#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_something() {
        assert_eq!(1 + 1, 2);
    }
}

// Conditional attributes
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
struct MyStruct {
    x: i32,
}

// Compile-time configuration
const IS_DEBUG: bool = cfg!(debug_assertions);

Workspaces

// Workspace root (Cargo.toml)
[workspace]
members = [
    "crates/core",
    "crates/cli",
    "crates/web",
]
exclude = ["crates/experimental"]

[workspace.package]
version = "0.2.0"
edition = "2021"
authors = ["Team"]
license = "MIT"

// Shared dependencies
[workspace.dependencies]
tokio = { version = "1.0", features = ["full"] }
serde = "1.0"

// Individual crate: crates/core/Cargo.toml
[package]
name = "my-core"
version.workspace = true
edition.workspace = true
authors.workspace = true

[dependencies]
tokio = { workspace = true }
serde = { workspace = true }

// Usage:
// cargo build -w (build all)
// cargo build -p my-core (specific crate)
// cargo test -w (test all)
// cargo publish -p my-cli

Build Scripts (build.rs)

// build.rs in crate root
use std::env;
use std::path::PathBuf;

fn main() {
    // Print build information
    println!("cargo:warning=Building for {}", env::var("PROFILE").unwrap());

    // Link C libraries
    println!("cargo:rustc-link-lib=mylib");
    println!("cargo:rustc-link-search=/usr/local/lib");

    // Conditional linking
    let target = env::var("TARGET").unwrap();
    if target.contains("x86_64") {
        println!("cargo:rustc-link-search=/opt/simd/lib");
    }

    // Define cfg
    println!("cargo:rustc-cfg=has_custom_build");

    // Rerun if changed
    println!("cargo:rerun-if-changed=build.rs");
    println!("cargo:rerun-if-changed=src/ffi.h");
    println!("cargo:rerun-if-env-changed=MYLIB_PATH");

    // Generate code
    #[cfg(feature = "codegen")]
    {
        let out_dir = PathBuf::from(env::var("OUT_DIR").unwrap());
        let dest = out_dir.join("generated.rs");
        std::fs::write(&dest, "pub const GENERATED: &str = \"hello\";").unwrap();
        println!("cargo:rustc-env=GENERATED_PATH={}", dest.display());
    }
}

// In src/lib.rs:
#[cfg(has_custom_build)]
println!("Custom build was used!");

// Include generated code
include!(concat!(env!("OUT_DIR"), "/generated.rs"));

Custom Profiles

// Cargo.toml
[profile.release]
opt-level = 3
lto = true
codegen-units = 1
strip = true
panic = "abort"

[profile.bench]
inherits = "release"
debug = true

[profile.custom]
inherits = "release"
split-debuginfo = "packed"
opt-level = 2

[profile.dev]
opt-level = 0
debug = true
split-debuginfo = "unpacked"

// Usage:
// cargo build (uses dev)
// cargo build --release
// cargo build --profile custom
// cargo bench (uses bench)

// Profile options:
// opt-level: 0-3, z (size), s (small)
// lto: true, fat, thin, false
// codegen-units: 1-256 (1=slower build, best optimization)
// panic: unwind, abort
// strip: false, true, symbols, debuginfo
// split-debuginfo: packed, unpacked, off
// debug: 0 (none), 1 (limited), 2 (full)
// incremental: true/false

Cross Compilation

// Install cross
// cargo install cross

// Build for different target
// cross build --target x86_64-unknown-linux-musl
// cross build --target aarch64-unknown-linux-gnu
// cross build --target wasm32-unknown-unknown
// cross build --target x86_64-pc-windows-gnu

// Rustup targets
// rustup target list
// rustup target add wasm32-unknown-unknown

// .cargo/config.toml
[build]
target = "x86_64-unknown-linux-musl"

[target.aarch64-unknown-linux-gnu]
linker = "aarch64-linux-gnu-gcc"

// Conditional dependencies for targets
[target.'cfg(unix)'.dependencies]
libc = "0.2"

[target.'cfg(target_os = "windows")'.dependencies]
winapi = "0.3"

[target.'cfg(target_arch = "wasm32")'.dependencies]
wasm-bindgen = "0.2"

// Profile settings per target
[profile.release]
opt-level = 3

[profile.dev]
split-debuginfo = "unpacked"

31. Modules, Visibility & Project Structure

mod, pub, Visibility Levels

// Private by default (no keyword)
fn private_function() {}

// pub — public everywhere
pub fn public_function() {}

// pub(crate) — public in this crate only
pub(crate) fn internal_function() {}

// pub(super) — public to parent module
pub(super) fn parent_visible_function() {}

// pub(in path::to::module) — public to specific module
pub(in crate::sibling) fn sibling_visible() {}

// Visibility on struct fields
pub struct MyStruct {
    pub public_field: i32,
    private_field: String,  // Private
    pub(crate) crate_field: bool,
}

// Visibility on enum variants
pub enum Status {
    pub Ready,      // Can't put pub on variants directly
    Processing,     // Enum itself is public; all variants inherit visibility
    Error(String),
}

// Trait visibility
pub trait MyTrait {
    fn public_method(&self);  // Public with trait
    fn _private_method(&self) {}  // Convention: leading _
}

// Trait impl visibility
impl MyTrait for MyType {
    fn public_method(&self) {}
}
// impl block visibility matches the trait/type visibility

// Re-exports with pub use
pub use std::collections::HashMap;
// Publicly re-exports HashMap from this module

Module Tree vs File Tree

// File structure:
// src/
//   lib.rs
//   math/
//     mod.rs
//     algebra.rs
//     geometry.rs
//   network/
//     mod.rs
//     http.rs
//     tcp.rs

// lib.rs declares module structure
pub mod math;
pub mod network;

// This tells Rust to load src/math/mod.rs or src/math.rs

// src/math/mod.rs
pub mod algebra;
pub mod geometry;

pub fn calculate() {}

// src/math/algebra.rs
pub fn solve_equation() {}

// Access paths:
// crate::math::calculate()
// crate::math::algebra::solve_equation()
// crate::math::geometry::... (if declared in mod.rs)

// Old-style inline modules
mod inline_module {
    pub fn inner() {}
}

fn use_inline() {
    inline_module::inner();
}

// File as module directory (src/network/mod.rs)
pub mod http;
pub mod tcp;

pub fn connect() {}

// Access: crate::network::connect(), crate::network::http::...

// File as module (src/network.rs) — NO submodules
pub fn connect() {}
// Access: crate::network::connect()
// Can't have network::http submodule without network/mod.rs

use & Re-exports

// Importing specific items
use std::collections::HashMap;
use std::fs::File;

// Glob imports
use std::io::*;  // Imports Read, Write, etc.

// Aliasing
use std::collections::HashMap as HMap;

// Multiple imports
use std::io::{self, Read, Write};
// self imports the io module itself

// Nested imports
use std::fs::{
    self,
    File,
    OpenOptions,
};

// Relative imports (crate-local)
use super::parent_module;
use super::super::grandparent;
use crate::root_module;
use self::sibling;

// Re-exporting
pub use std::collections::HashMap;
// User can do: use my_crate::HashMap

// Selective re-export
pub use crate::internal::process;
// Hides internal module, exposes process function

// Re-export with alias
pub use std::io::Result as IoResult;

// Glob re-export
pub use crate::utils::*;

// Conditional re-exports
#[cfg(feature = "serde")]
pub use serde::{Serialize, Deserialize};

Prelude Pattern

// src/lib.rs or src/prelude.rs
pub mod prelude {
    // Common traits users will want
    pub use crate::traits::{MyTrait, AnotherTrait};

    // Common types
    pub use crate::types::{Result, Error};

    // Frequently used functions
    pub use crate::builder::Builder;
}

// User code:
use my_crate::prelude::*;

// Now they have:
// - MyTrait, AnotherTrait
// - Result, Error
// - Builder

// Standard library examples:
use std::prelude::v1::*;  // Default for every Rust program
// Imports: Sized, Sync, Send, Unpin, Drop, Clone, Copy,
//          Default, Eq, Ord, AsRef, AsMut, From, Into,
//          IntoIterator, Iterator, DoubleEndedIterator,
//          ExactSizeIterator, ToString, Option, Result, Vec, String, etc.

// Creating a minimal prelude for a library
pub mod prelude {
    pub use crate::{
        Database,
        Query,
        ConnectionPool,
        Error,
        Result,
    };
}

Library vs Binary Crate Structure

// Cargo.toml for library
[package]
name = "my_lib"

[lib]
name = "my_lib"

// src/lib.rs — the public API
pub mod prelude;
pub mod error;
pub mod types;
pub mod builder;

pub use error::{Error, Result};
pub use types::Config;
pub use builder::Builder;

// Library doesn't need main.rs; structure is internal

// Cargo.toml for binary
[package]
name = "my_cli"

[[bin]]
name = "my_cli"
path = "src/main.rs"

// src/main.rs — entry point
mod cli;
mod commands;
mod config;

use cli::App;

fn main() {
    let app = App::new();
    app.run();
}

// src/cli.rs — internal module
pub struct App;

// src/commands/ — internal module structure
pub fn handle_command() {}

// Library + Binary combo
[package]
name = "my_project"

[lib]
name = "my_lib"

[[bin]]
name = "my_cli"

// src/lib.rs — public library
pub mod processor;
pub mod config;

// src/main.rs — uses library
use my_lib::processor;
use my_lib::config;

fn main() {
    let config = config::load().unwrap();
    processor::run(&config);
}

Common Project Layouts

// Cargo.toml for this structure
[package]
name = "my_crate"
version = "0.1.0"

[lib]
name = "my_crate"

[[example]]
name = "basic"

[[bench]]
name = "processing"
harness = false

// src/lib.rs
pub mod prelude;
pub mod error;
pub mod core;
pub mod utils;

pub use error::{Error, Result};
pub use core::Processor;

// src/error.rs
pub type Result<T> = std::result::Result<T, Error>;

#[derive(Debug)]
pub enum Error {
    IoError(std::io::Error),
    ParseError(String),
}

// src/core/mod.rs
pub mod processor;
pub mod state;

pub use processor::Processor;
pub use state::State;

// src/core/processor.rs
pub struct Processor;
impl Processor {
    pub fn process(&self, data: &str) -> crate::Result<()> {
        todo!()
    }
}

// examples/basic.rs (compiled separately)
use my_crate::prelude::*;

fn main() {
    let proc = Processor::new();
    let _ = proc.process("data");
}

// tests/test_api.rs
use my_crate::prelude::*;

#[test]
fn test_processor() {
    let proc = Processor::new();
    assert!(proc.process("valid").is_ok());
}

32. Embedded Rust & no_std

#![no_std] & #![no_main]

// Bare-metal binary without OS runtime
#![no_std]
#![no_main]

use core::panic::PanicInfo;

#[panic_handler]
fn panic(_info: &PanicInfo) -> ! {
    loop {}
}

#[no_mangle]
pub extern "C" fn _start() -> ! {
    loop {}
}

// With no_std, unavailable:
// - std::io, std::fs, std::net
// - std::vec, std::string (use alloc crate instead)
// - std::thread, std::sync (no_std compatible: core::sync::atomic)
// - System memory allocation

// With no_std, available:
// - core:: primitives (core::option, core::result, core::iter)
// - Core traits (Copy, Clone, Drop, Fn)
// - core::mem, core::ptr, core::fmt
// - core::sync::atomic for lock-free synchronization

// no_std with alloc support
#![no_std]

extern crate alloc;

use alloc::vec::Vec;
use alloc::string::String;

fn work() {
    let mut v = Vec::new();
    v.push(1);

    let s = String::from("hello");
}

// Requires a global allocator
use alloc::alloc::GlobalAlloc;

struct MyAllocator;

unsafe impl GlobalAlloc for MyAllocator {
    unsafe fn alloc(&self, layout: alloc::alloc::Layout) -> *mut u8 {
        todo!()
    }

    unsafe fn dealloc(&self, ptr: *mut u8, layout: alloc::alloc::Layout) {
        todo!()
    }
}

#[global_allocator]
static ALLOC: MyAllocator = MyAllocator;

embedded-hal Traits

use embedded_hal::digital::{InputPin, OutputPin};
use embedded_hal::serial::{Read, Write};
use embedded_hal::spi::Transfer;

// GPIO abstraction
trait OutputPin {
    type Error;
    fn set_low(&mut self) -> Result<(), Self::Error>;
    fn set_high(&mut self) -> Result<(), Self::Error>;
}

trait InputPin {
    type Error;
    fn is_high(&self) -> Result<bool, Self::Error>;
    fn is_low(&self) -> Result<bool, Self::Error>;
}

// Example: STM32 LED blink (conceptual)
struct Led<P: OutputPin> {
    pin: P,
}

impl<P: OutputPin> Led<P> {
    fn new(pin: P) -> Self {
        Led { pin }
    }

    fn on(&mut self) -> Result<(), P::Error> {
        self.pin.set_high()
    }

    fn off(&mut self) -> Result<(), P::Error> {
        self.pin.set_low()
    }
}

// UART trait
trait Serial<Word = u8>: Read<Word> + Write<Word> {}

fn generic_uart_write<S: Serial>(serial: &mut S, data: &[u8]) -> Result<(), S::Error> {
    for &byte in data {
        serial.write(byte)?;
    }
    Ok(())
}

// SPI trait
trait Transfer<Word = u8> {
    type Error;

    fn transfer(&mut self, words: &mut [Word]) -> Result<(), Self::Error>;
}

fn spi_read<S: Transfer<u8>>(spi: &mut S, len: usize) -> Result<Vec<u8>, S::Error> {
    let mut buf = vec![0u8; len];
    spi.transfer(&mut buf)?;
    Ok(buf)
}

// Timer trait
trait CountDown {
    type Time;
    type Error;

    fn start<T>(&mut self, count: T) -> Result<(), Self::Error>
    where
        T: Into<Self::Time>;

    fn wait(&mut self) -> Result<(), Self::Error>;
}

fn delay<T: CountDown>(timer: &mut T, ms: u32) -> Result<(), T::Error> {
    timer.start(ms)?;
    timer.wait()
}

Cortex-M & RISC-V Targets

// For ARM Cortex-M microcontrollers
// Cargo.toml:
[package]
[dependencies]
cortex-m = "0.7"
cortex-m-rt = "0.7"

[profile.release]
opt-level = "z"

[build]
target = "thumbv7em-none-eabihf"  # ARM Cortex-M4/M7 (hard float)
# or thumbv6m-none-eabi for M0/M0+

// Cortex-M startup
#![no_std]
#![no_main]

use cortex_m_rt::entry;

#[entry]
fn main() -> ! {
    loop {}
}

// RISC-V targets
// [build]
// target = "riscv32i-unknown-none-elf"
// target = "riscv64imac-unknown-none-elf"

#![no_std]
#![no_main]

use riscv_rt::entry;

#[entry]
fn main() -> ! {
    // RISC-V main
    loop {}
}

// Accessing memory-mapped registers (Cortex-M example)
use cortex_m::peripheral::NVIC;

fn enable_interrupt() {
    unsafe {
        NVIC::unmask(cortex_m::peripheral::Interrupt::TIM2);
    }
}

// RISC-V machine register access
use riscv::register::*;

fn read_cycle() -> u64 {
    cycle::read() as u64
}

Interrupt Handling

// Cortex-M interrupt handlers
use cortex_m_rt::interrupt;

#[interrupt]
fn SysTick() {
    // System timer interrupt
    // Handled automatically
}

#[interrupt]
fn UART0() {
    // UART interrupt
    // Process serial data
}

// RISC-V interrupts
#[riscv_rt::entry]
fn main() -> ! {
    unsafe {
        riscv::interrupt::enable();
    }

    loop {}
}

#[allow(non_snake_case)]
#[no_mangle]
pub fn ExceptionHandler(trap_frame: &riscv_rt::TrapFrame) {
    match riscv::register::scause::read().cause() {
        riscv::register::scause::Trap::Interrupt(i) => {
            match i {
                riscv::register::scause::Interrupt::MachineTimer => {
                    // Handle timer
                }
                _ => {}
            }
        }
        riscv::register::scause::Trap::Exception(e) => {
            match e {
                riscv::register::scause::Exception::IllegalInstruction => {
                    // Handle illegal instruction
                }
                _ => {}
            }
        }
    }
}

// Cortex-M with critical sections
use cortex_m::interrupt;

fn critical_section() {
    interrupt::free(|cs| {
        // No interrupts during this block
        // cs: CriticalSection token
        perform_atomic_operation();
    });
}

fn perform_atomic_operation() {
    // Protected from interrupts
}

Memory-Mapped I/O

use core::ptr::{read_volatile, write_volatile};
use core::sync::atomic::{AtomicU32, Ordering};

// Register structure
#[repr(C)]
struct UartRegs {
    data: u32,      // Offset 0x0
    status: u32,    // Offset 0x4
    control: u32,   // Offset 0x8
}

// Bare register access (unsafe)
fn uart_read_char(uart_base: *const UartRegs) -> u8 {
    unsafe {
        let data = read_volatile(&(*uart_base).data);
        (data & 0xFF) as u8
    }
}

fn uart_write_char(uart_base: *mut UartRegs, ch: u8) {
    unsafe {
        write_volatile(&mut (*uart_base).data, ch as u32);
    }
}

// Volatile wrapper for registers
struct Uart {
    base: *mut UartRegs,
}

impl Uart {
    fn new(base: usize) -> Self {
        Uart { base: base as *mut _ }
    }

    fn read(&self) -> u8 {
        unsafe {
            let data = read_volatile(&(*self.base).data);
            (data & 0xFF) as u8
        }
    }

    fn write(&mut self, ch: u8) {
        unsafe {
            write_volatile(&mut (*self.base).data, ch as u32);
        }
    }

    fn is_ready(&self) -> bool {
        unsafe {
            let status = read_volatile(&(*self.base).status);
            (status & 1) != 0
        }
    }
}

// Atomic register access (for shared mutable state)
struct AtomicReg(AtomicU32);

fn atomic_read(reg: &AtomicReg) -> u32 {
    reg.0.load(Ordering::SeqCst)
}

fn atomic_write(reg: &mut AtomicReg, value: u32) {
    reg.0.store(value, Ordering::SeqCst);
}

Real-Time Constraints

// Predictable execution time (no allocations in hot path)
fn process_sensor_data_deterministic(data: &[u8]) {
    // Stack-allocated buffer, no heap
    let mut output = [0u8; 256];

    // Fixed iterations, no loops with unknown count
    for i in 0..data.len().min(256) {
        output[i] = process(data[i]);
    }
}

// WCET (Worst-Case Execution Time) aware code
fn compute_with_bounds() {
    // Avoid:
    // - malloc/Vec allocations
    // - system calls
    // - loops with data-dependent iteration counts
    // - branches that depend on input (timing attacks)

    // Prefer:
    // - Stack-allocated fixed buffers
    // - Loop unrolling
    // - Fixed WCET operations

    let mut sum = 0u32;
    for &val in &[1, 2, 3, 4] {
        sum = sum.wrapping_add(val);
    }
}

// Soft real-time with spinlock
use core::sync::atomic::{AtomicBool, Ordering};

struct Mutex(AtomicBool);

impl Mutex {
    fn lock(&self) {
        while self.0.compare_exchange(
            false,
            true,
            Ordering::Acquire,
            Ordering::Relaxed,
        ).is_err() {
            // Spinlock
        }
    }

    fn unlock(&self) {
        self.0.store(false, Ordering::Release);
    }
}

// Priority inversion awareness
fn high_priority_task() {
    // Should not hold locks for long
    // Should not call into low-priority code
}

fn low_priority_task() {
    // Can use locks safely
    // Won't block high-priority tasks
}

33. WebAssembly (Wasm)

wasm-pack & wasm-bindgen

// Cargo.toml for WASM library
[package]
name = "wasm-lib"

[lib]
crate-type = ["cdylib", "rlib"]

[dependencies]
wasm-bindgen = "0.2"
web-sys = "0.3"
js-sys = "0.3"

// src/lib.rs
use wasm_bindgen::prelude::*;

// Exported to JavaScript
#[wasm_bindgen]
pub fn greet(name: &str) -> String {
    format!("Hello, {}!", name)
}

// JavaScript interop
#[wasm_bindgen(js_namespace = console)]
extern "C" {
    pub fn log(s: &str);
}

#[wasm_bindgen]
pub fn hello_world() {
    log("Hello from Rust!");
}

// Custom types with JavaScript
#[wasm_bindgen]
pub struct Counter {
    count: i32,
}

#[wasm_bindgen]
impl Counter {
    #[wasm_bindgen(constructor)]
    pub fn new() -> Counter {
        Counter { count: 0 }
    }

    pub fn increment(&mut self) {
        self.count += 1;
    }

    pub fn get_count(&self) -> i32 {
        self.count
    }
}

// Build:
// wasm-pack build --target web
// Generates pkg/ directory with WASM + JS bindings

// JavaScript usage:
// import init, { Counter } from "./pkg/wasm_lib.js";
//
// await init();
// const counter = new Counter();
// counter.increment();
// console.log(counter.get_count());

wasm32-unknown-unknown Target

// Setup
// rustup target add wasm32-unknown-unknown

// Cargo.toml
[lib]
crate-type = ["cdylib"]

// Build bare WASM (no bindings)
// cargo build --target wasm32-unknown-unknown --release

// The resulting WASM file in target/wasm32-unknown-unknown/release/

// Manual WASM export (without wasm-bindgen)
#[no_mangle]
pub extern "C" fn add(a: i32, b: i32) -> i32 {
    a + b
}

// Load in JavaScript:
// const wasm = await WebAssembly.instantiateStreaming(
//     fetch('module.wasm')
// );
// const result = wasm.instance.exports.add(5, 3);

// Memory access
#[no_mangle]
pub extern "C" fn get_memory_ptr() -> *const u8 {
    &[1, 2, 3, 4, 5][0]
}

// Linear memory (WASM's memory model)
static mut BUFFER: [u8; 1024] = [0; 1024];

#[no_mangle]
pub extern "C" fn buffer_addr() -> *const u8 {
    unsafe { &BUFFER[0] }
}

#[no_mangle]
pub extern "C" fn process_buffer(len: usize) {
    unsafe {
        for i in 0..len.min(1024) {
            BUFFER[i] = BUFFER[i].wrapping_add(1);
        }
    }
}

JS Interop

use wasm_bindgen::prelude::*;
use web_sys::window;

// Call JavaScript functions
#[wasm_bindgen]
pub fn call_js_function() {
    web_sys::window()
        .and_then(|w| w.document())
        .and_then(|d| d.get_element_by_id("output"))
        .and_then(|e| {
            e.set_text_content(Some("Hello from Rust!"));
            Some(())
        });
}

// Access DOM
#[wasm_bindgen]
pub fn modify_dom() {
    let window = web_sys::window().expect("no window");
    let document = window.document().expect("no document");
    let body = document.body().expect("no body");

    let div = document.create_element("div").unwrap();
    div.set_text_content(Some("Generated by Rust"));
    body.append_child(&div).unwrap();
}

// Event handling
use wasm_bindgen::JsCast;
use web_sys::HtmlInputElement;

#[wasm_bindgen]
pub fn setup_click_handler() {
    let window = web_sys::window().unwrap();
    let document = window.document().unwrap();

    if let Some(button) = document.get_element_by_id("btn") {
        let closure = Closure::wrap(Box::new(|_: web_sys::Event| {
            web_sys::console::log_1(&"Button clicked!".into());
        }) as Box);

        button
            .add_event_listener_with_callback("click", closure.as_ref().unchecked_ref())
            .unwrap();

        closure.forget();
    }
}

// Return JavaScript objects
#[wasm_bindgen]
pub fn create_js_object() -> wasm_bindgen::JsValue {
    use js_sys::Object;

    let obj = Object::new();
    js_sys::Reflect::set(&obj, &"name".into(), &"Rust".into()).unwrap();
    js_sys::Reflect::set(&obj, &"version".into(), &1.into()).unwrap();

    obj.into()
}

// Promise support (async)
use wasm_bindgen_futures::JsFuture;

#[wasm_bindgen]
pub async fn fetch_data(url: &str) -> Result<String, JsValue> {
    let window = web_sys::window().ok_or_else(|| "no window".into())?;
    let resp_value = JsFuture::from(window.fetch_with_str(url))
        .await?;

    let resp: web_sys::Response = resp_value.dyn_into()?;

    let text = JsFuture::from(resp.text()?).await?;

    Ok(text.as_string().unwrap_or_default())
}

wasm-wasi & System Calls

// wasm32-wasi target enables system-like behavior
// rustup target add wasm32-wasi

// Cargo.toml
[build]
target = "wasm32-wasi"

[dependencies]
# Can use std now!

// src/main.rs — can use std::io, std::fs, etc.
use std::fs;
use std::io::{self, Read};

fn main() {
    // WASI provides file I/O
    let data = fs::read_to_string("input.txt").unwrap();
    println!("Read: {}", data);
}

// Build:
// cargo build --target wasm32-wasi --release

// Run with wasmtime:
// wasmtime target/wasm32-wasi/release/my_app.wasm

// Available WASI capabilities:
// - File I/O (limited to allowed directories)
// - Environment variables (std::env)
// - Command-line arguments (std::env::args)
// - Time (std::time)
// - Process exit codes

// Example: file processing
fn process_file(path: &str) -> io::Result<String> {
    let mut file = fs::File::open(path)?;
    let mut contents = String::new();
    file.read_to_string(&mut contents)?;

    Ok(contents.to_uppercase())
}

// WASI runtime security (sandboxed execution)
// Files accessible only within granted directories
// Network access disabled by default
// System calls restricted

Performance Considerations

// WASM performance tips

// 1. Minimize memory allocations
#[wasm_bindgen]
pub fn process_good(data: &[u8]) -> Vec<u8> {
    // Reuse input buffer, single output allocation
    data.iter().map(|&b| b * 2).collect()
}

#[wasm_bindgen]
pub fn process_bad(data: &[u8]) -> Vec<u8> {
    // Multiple allocations: intermediate vecs
    let doubled: Vec<u8> = data.iter().map(|&b| b * 2).collect();
    let filtered: Vec<u8> = doubled.into_iter().filter(|&b| b > 10).collect();
    filtered
}

// 2. Batch JavaScript interop
#[wasm_bindgen]
pub fn batch_calculation(inputs: &[i32]) -> Vec<i32> {
    // Process all at once, return results
    // Avoid calling back to JS in a loop
    inputs.iter().map(|x| x * 2).collect()
}

// DON'T do this:
// #[wasm_bindgen]
// pub fn slow_calculation(inputs: &[i32]) -> Vec<i32> {
//     let mut results = Vec::new();
//     for x in inputs {
//         let processed = web_sys::expensive_js_call(x);
//         results.push(processed);
//     }
//     results
// }

// 3. Use typed arrays
#[wasm_bindgen]
pub fn fill_buffer(buf: &mut [u8], value: u8) {
    buf.fill(value);
}

// JavaScript:
// const buf = new Uint8Array(1000);
// fillBuffer(buf, 42);

// 4. Avoid string conversion overhead
#[wasm_bindgen]
pub fn process_bytes(data: &[u8]) -> Vec<u8> {
    // Work with bytes directly
    data.iter().map(|&b| b.wrapping_add(1)).collect()
}

// 5. Profile with wasm-opt
// cargo install wasm-opt
// wasm-opt -Oz output.wasm -o output.wasm

// Binary size optimization
// Cargo.toml:
// [profile.release]
// opt-level = "z"    # Optimize for size
// lto = true
// codegen-units = 1

Component Model (Future)

// WebAssembly Component Model — cross-language composition
// (Experimental, future direction)

// Define interfaces
// interface.wit
package example:hello;

interface hello {
    greet: func(name: string) -> string;
}

world my-world {
    export hello;
}

// Compile:
// wasm-tools component bind output.wasm -o component.wasm

// Components allow:
// - Language-neutral interfaces
// - Cross-language WASM composition
// - System-like capabilities
// - Better tooling and type safety

// This is the future of WASM standardization

34. Networking & Async I/O

tokio Runtime Deep Dive

use tokio::runtime::Runtime;
use std::time::Duration;

// Create runtime
fn main() {
    let rt = Runtime::new().unwrap();

    rt.block_on(async {
        println!("Running async code");
    });
}

// Builder for custom configuration
fn custom_runtime() {
    let rt = tokio::runtime::Builder::new_multi_thread()
        .worker_threads(4)
        .thread_name("my-worker")
        .stack_size(2 * 1024 * 1024)  // 2MB stack
        .enable_all()                  // Enable all features
        .build()
        .unwrap();

    rt.block_on(async {
        // Async work
    });
}

// Single-threaded runtime (for simple apps)
fn single_thread() {
    let rt = tokio::runtime::Builder::new_current_thread()
        .enable_all()
        .build()
        .unwrap();

    rt.block_on(async {
        // All tasks run on single thread
    });
}

// Work stealing scheduler
// - Multiple threads (worker pool)
// - Each thread has a task queue
// - Idle threads steal from busy threads
// - Excellent cache locality
// - Fair task distribution

// Task spawning
async fn main_async() {
    // Spawn task on runtime
    let handle = tokio::spawn(async {
        println!("Task running");
        42
    });

    // Wait for result
    let result = handle.await.unwrap();
    println!("Result: {}", result);
}

// Blocking code in async context
async fn io_bound() {
    // For actual I/O (network, disk), use async APIs
    // For CPU-bound code, use tokio::task::block_in_place
    let result = tokio::task::block_in_place(|| {
        // Expensive computation or blocking call
        (0..1_000_000).sum::<i32>()
    });

    println!("Result: {}", result);
}

// Keeping runtime alive
struct AppState {
    runtime: Runtime,
}

impl AppState {
    fn new() -> Self {
        AppState {
            runtime: Runtime::new().unwrap(),
        }
    }

    fn run<F>(&mut self, future: F) -> F::Output
    where
        F: std::future::Future,
    {
        self.runtime.block_on(future)
    }
}

TCP/UDP with tokio

use tokio::net::{TcpListener, TcpStream, UdpSocket};
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use std::net::SocketAddr;

// TCP Server
async fn tcp_server() -> tokio::io::Result<()> {
    let listener = TcpListener::bind("127.0.0.1:8080").await?;

    loop {
        let (socket, peer_addr) = listener.accept().await?;
        println!("Accepted: {}", peer_addr);

        tokio::spawn(async move {
            if let Err(e) = handle_connection(socket).await {
                eprintln!("Error: {}", e);
            }
        });
    }
}

async fn handle_connection(mut socket: TcpStream) -> tokio::io::Result<()> {
    let mut buf = [0; 1024];

    loop {
        let n = socket.read(&mut buf).await?;

        if n == 0 {
            return Ok(());  // Connection closed
        }

        let data = &buf[..n];
        println!("Received: {:?}", String::from_utf8_lossy(data));

        socket.write_all(b"ACK").await?;
    }
}

// TCP Client
async fn tcp_client() -> tokio::io::Result<()> {
    let mut stream = TcpStream::connect("127.0.0.1:8080").await?;

    stream.write_all(b"Hello, server!").await?;

    let mut buf = [0; 1024];
    let n = stream.read(&mut buf).await?;

    println!("Response: {}", String::from_utf8_lossy(&buf[..n]));

    Ok(())
}

// UDP Socket
async fn udp_server() -> tokio::io::Result<()> {
    let socket = UdpSocket::bind("127.0.0.1:9000").await?;

    let mut buf = [0; 1024];

    loop {
        let (n, peer) = socket.recv_from(&mut buf).await?;
        println!("UDP from {}: {:?}", peer, String::from_utf8_lossy(&buf[..n]));

        socket.send_to(b"ACK", peer).await?;
    }
}

// Multiple concurrent connections
async fn handle_many_connections() {
    let listener = TcpListener::bind("127.0.0.1:8080")
        .await
        .unwrap();

    let mut interval = tokio::time::interval(std::time::Duration::from_secs(1));

    loop {
        tokio::select! {
            result = listener.accept() => {
                if let Ok((socket, addr)) = result {
                    println!("New: {}", addr);
                    tokio::spawn(async move {
                        let _ = handle_connection(socket).await;
                    });
                }
            }
            _ = interval.tick() => {
                println!("Tick");
            }
        }
    }
}

Tower Middleware

use tower::{Service, ServiceExt, service_fn};
use std::task::{Context, Poll};
use std::pin::Pin;
use std::future::Future;

// Custom middleware as a layer
struct LoggingService<S> {
    inner: S,
}

impl<S> Service<String> for LoggingService<S>
where
    S: Service<String> + Send + 'static,
    S::Future: Send + 'static,
{
    type Response = S::Response;
    type Error = S::Error;
    type Future = Pin<Box<dyn Future<Output = Result<S::Response, S::Error>> + Send>>;

    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
        self.inner.poll_ready(cx)
    }

    fn call(&mut self, req: String) -> Self::Future {
        println!("Handling: {}", req);

        let future = self.inner.call(req);

        Box::pin(async move {
            let response = future.await?;
            println!("Done");
            Ok(response)
        })
    }
}

// Layer to wrap services
use tower::Layer;

struct LoggingLayer;

impl<S> Layer<S> for LoggingLayer {
    type Service = LoggingService<S>;

    fn layer(&self, inner: S) -> Self::Service {
        LoggingService { inner }
    }
}

// Composing multiple middleware
use tower::layer::Stack;

async fn middleware_example() {
    let service = service_fn(|req: String| async move {
        Ok::

// Hyper — low-level HTTP
use hyper::{Server, Body, Request, Response, StatusCode};
use hyper::service::{service_fn, make_service_fn};

async fn handle(_req: Request<Body>) -> Result<Response<Body>, hyper::Error> {
    Ok(Response::new(Body::from("Hello, World!")))
}

async fn hyper_server() {
    let make_svc = make_service_fn(|_conn| async {
        Ok::<_, hyper::Error>(service_fn(handle))
    });

    let addr = ([127, 0, 0, 1], 3000).into();
    let server = Server::bind(&addr).serve(make_svc);

    println!("Listening on http://{}", addr);
    server.await.unwrap();
}

// Axum — high-level framework
use axum::{
    routing::{get, post},
    Router,
    Json,
    extract::Path,
};
use serde_json::json;

// Define routes
async fn root() -> &'static str {
    "Hello!"
}

async fn user(Path(id): Path<u32>) -> Json<serde_json::Value> {
    Json(json!({
        "id": id,
        "name": "User"
    }))
}

async fn create_user(Json(payload): Json<serde_json::Value>) -> Json<serde_json::Value> {
    Json(payload)
}

async fn axum_server() {
    let app = Router::new()
        .route("/", get(root))
        .route("/user/:id", get(user))
        .route("/user", post(create_user));

    let listener = tokio::net::TcpListener::bind("127.0.0.1:3000")
        .await
        .unwrap();

    axum::serve(listener, app).await.unwrap();
}

// Extractors (parse request data)
use axum::extract::{Query, Headers};

async fn search(
    Query(params): Query<std::collections::HashMap<String, String>>,
) -> String {
    format!("Query: {:?}", params)
}

// Middleware in Axum
use tower::ServiceBuilder;

async fn with_middleware() {
    let app = Router::new()
        .route("/", get(root))
        .layer(
            ServiceBuilder::new()
                .layer(tower_http::trace::TraceLayer::new_for_http())
        );
}

use tokio::net::TcpStream;
use std::sync::Arc;
use tokio::sync::Semaphore;
use std::collections::VecDeque;

// Simple connection pool
struct ConnectionPool {
    available: Arc<Semaphore>,
    connections: Arc<tokio::sync::Mutex<VecDeque<TcpStream>>>,
    max_size: usize,
}

impl ConnectionPool {
    fn new(max_size: usize) -> Self {
        ConnectionPool {
            available: Arc::new(Semaphore::new(max_size)),
            connections: Arc::new(tokio::sync::Mutex::new(VecDeque::new())),
            max_size,
        }
    }

    async fn get(&self, addr: &str) -> tokio::io::Result<PooledConnection> {
        self.available.acquire().await.unwrap();

        let mut conns = self.connections.lock().await;

        let stream = if let Some(conn) = conns.pop_front() {
            conn
        } else {
            TcpStream::connect(addr).await?
        };

        Ok(PooledConnection {
            stream: Some(stream),
            pool: self.available.clone(),
        })
    }
}

// RAII connection guard
struct PooledConnection {
    stream: Option<TcpStream>,
    pool: Arc<Semaphore>,
}

impl Drop for PooledConnection {
    fn drop(&mut self) {
        self.pool.add_permits(1);
    }
}

// Using deadpool crate (recommended)
use deadpool::managed::{Pool, Object};

async fn with_deadpool() {
    // let pool = Pool::builder(...)
    //     .max_size(10)
    //     .build()
    //     .unwrap();
    //
    // let conn = pool.get().await.unwrap();
    // // Use conn
    // // Returned to pool on drop
}

// sqlx with connection pool (database)
async fn db_pool() {
    let pool = sqlx::postgres::PgPoolOptions::new()
        .max_connections(5)
        .connect("postgres://user:pass@localhost/db")
        .await
        .unwrap();

    // Pool manages connections automatically
    let row = sqlx::query_as::<_, (i32,)>("SELECT 1")
        .fetch_one(&pool)
        .await
        .unwrap();
}

use tokio::sync::broadcast;
use tokio::signal;

async fn graceful_shutdown() {
    let (tx, mut rx) = broadcast::channel(1);

    // Spawn server task
    let server_handle = tokio::spawn(async move {
        let listener = tokio::net::TcpListener::bind("127.0.0.1:8080")
            .await
            .unwrap();

        loop {
            tokio::select! {
                result = listener.accept() => {
                    if let Ok((socket, _)) = result {
                        let mut rx = rx.subscribe();
                        tokio::spawn(async move {
                            handle_client(socket, &mut rx).await;
                        });
                    }
                }
                _ = rx.recv() => {
                    println!("Shutting down server");
                    break;
                }
            }
        }
    });

    // Wait for signal
    signal::ctrl_c().await.unwrap();
    println!("Shutdown signal received");

    // Broadcast shutdown
    let _ = tx.send(());

    // Wait for server to finish
    server_handle.await.unwrap();
}

async fn handle_client(
    mut socket: tokio::net::TcpStream,
    shutdown: &mut broadcast::Receiver<()>,
) {
    let mut buf = [0; 1024];

    loop {
        tokio::select! {
            result = socket.read(&mut buf) => {
                match result {
                    Ok(0) => break,  // Connection closed
                    Ok(n) => {
                        let _ = socket.write_all(&buf[..n]).await;
                    }
                    Err(_) => break,
                }
            }
            _ = shutdown.recv() => {
                println!("Client shutdown");
                break;
            }
        }
    }
}

// With axum
use axum::Router;
use tower::ServiceBuilder;

async fn axum_graceful_shutdown() {
    let app = Router::new();

    let listener = tokio::net::TcpListener::bind("127.0.0.1:3000")
        .await
        .unwrap();

    let (tx, rx) = tokio::sync::oneshot::channel();

    // Spawn with graceful shutdown
    tokio::spawn(async move {
        axum::serve(listener, app)
            .with_graceful_shutdown(async {
                let _ = rx.await;
            })
            .await
            .unwrap();
    });

    // Later: signal shutdown
    let _ = tx.send(());
}