DEV Community: mihir mohapatra

Rust Concepts: Macros, Modules, Testing & Unsafe Rust (Part 3)

mihir mohapatra — Wed, 20 May 2026 06:59:05 +0000

This is Part 3 of the Core Rust Concepts series.

Part 1 — Ownership, Borrowing, Lifetimes, Traits, Result/Option, Pattern Matching

Part 2 — Closures, Iterators, Generics, Enums, Smart Pointers, Async/Await

Macros
Modules & the Cargo Ecosystem
Testing in Rust
Closures as Return Types & Higher-Order Functions
Unsafe Rust
FFI — Calling C from Rust

13. Macros

Rust has two kinds of macros: declarative (macro_rules!) and procedural (proc macros). Both generate code at compile time — not at runtime.

Declarative Macros (`macro_rules!`)

These work by pattern matching on the syntax you pass in and expanding to new code.

// Define a macro
macro_rules! say_hello {
    () => {
        println!("Hello!");
    };
    ($name:expr) => {
        println!("Hello, {}!", $name);
    };
}

fn main() {
    say_hello!();            // Hello!
    say_hello!("Rustacean"); // Hello, Rustacean!
}

A more practical example — a map! macro that builds a HashMap:

macro_rules! map {
    ($($key:expr => $val:expr),*) => {{
        let mut m = std::collections::HashMap::new();
        $(m.insert($key, $val);)*
        m
    }};
}

fn main() {
    let scores = map!("Alice" => 95, "Bob" => 87, "Carol" => 92);
    println!("{:?}", scores);
}

Procedural Macros (Derive)

Proc macros operate on the token stream — used for #[derive(...)], custom attributes, and function-like macros.

// The most common proc macro you'll use — derive
#[derive(Debug, Clone, PartialEq)]
struct User {
    name: String,
    age: u32,
}

fn main() {
    let u1 = User { name: String::from("Alice"), age: 30 };
    let u2 = u1.clone();
    println!("{:?}", u1);       // Debug print
    println!("{}", u1 == u2);   // PartialEq: true
}

💡 Popular crates like serde use proc macros to generate serialization/deserialization code automatically with just #[derive(Serialize, Deserialize)].

14. Modules & the Cargo Ecosystem

Modules

Rust organizes code into a module tree. You define modules with mod, control visibility with pub, and bring items into scope with use.

mod math {
    pub fn add(a: i32, b: i32) -> i32 { a + b }
    pub fn subtract(a: i32, b: i32) -> i32 { a - b }

    pub mod advanced {
        pub fn power(base: i32, exp: u32) -> i32 {
            base.pow(exp)
        }
    }
}

use math::advanced::power;

fn main() {
    println!("{}", math::add(3, 4));      // 7
    println!("{}", math::subtract(10, 4)); // 6
    println!("{}", power(2, 8));           // 256
}

Splitting across files

src/
├── main.rs
├── math.rs          ← mod math; in main.rs
└── math/
    └── advanced.rs  ← pub mod advanced; in math.rs

// main.rs
mod math;
use math::add;

fn main() {
    println!("{}", add(2, 3));
}

// math.rs
pub mod advanced;

pub fn add(a: i32, b: i32) -> i32 { a + b }

Cargo — The Build System & Package Manager

# Cargo.toml
[package]
name    = "my_app"
version = "0.1.0"
edition = "2021"

[dependencies]
serde       = { version = "1", features = ["derive"] }
tokio       = { version = "1", features = ["full"] }
reqwest     = { version = "0.11", features = ["json"] }
anyhow      = "1"

[dev-dependencies]
pretty_assertions = "1"

Essential Cargo commands:

cargo new my_app        # create a new project
cargo build             # compile (debug)
cargo build --release   # compile (optimized)
cargo run               # build + run
cargo test              # run all tests
cargo doc --open        # generate and open docs
cargo add serde         # add a dependency
cargo update            # update dependencies
cargo clippy            # lint your code
cargo fmt               # auto-format

15. Testing in Rust

Testing is built into the language — no extra framework needed. Tests live right next to your code.

Unit Tests

pub fn divide(a: f64, b: f64) -> Option<f64> {
    if b == 0.0 { None } else { Some(a / b) }
}

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

    #[test]
    fn test_divide_normal() {
        assert_eq!(divide(10.0, 2.0), Some(5.0));
    }

    #[test]
    fn test_divide_by_zero() {
        assert_eq!(divide(5.0, 0.0), None);
    }

    #[test]
    #[should_panic(expected = "index out of bounds")]
    fn test_panic() {
        let v = vec![1, 2, 3];
        let _ = v[10]; // should panic
    }

    #[test]
    fn test_with_message() {
        let result = divide(9.0, 3.0);
        assert!(result.is_some(), "expected Some, got None");
        assert!((result.unwrap() - 3.0).abs() < f64::EPSILON);
    }
}

Run with:

cargo test                        # run all tests
cargo test test_divide            # run tests matching the name
cargo test -- --nocapture         # show println! output

Integration Tests

Integration tests live in a top-level tests/ folder and test your public API.

src/
└── lib.rs
tests/
└── integration_test.rs

// tests/integration_test.rs
use my_app::divide;

#[test]
fn test_public_api() {
    assert_eq!(divide(20.0, 4.0), Some(5.0));
}

Test with Result

#[test]
fn test_returns_result() -> Result<(), String> {
    let val = divide(10.0, 2.0).ok_or("division failed")?;
    assert_eq!(val, 5.0);
    Ok(())
}

💡 Use cargo test -- --test-threads=1 if tests share state and need to run sequentially.

16. Closures as Return Types & Higher-Order Functions

Rust can return closures from functions, enabling functional patterns like currying and function factories.

// Return a closure using impl Fn
fn make_adder(x: i32) -> impl Fn(i32) -> i32 {
    move |y| x + y
}

// Return a closure on the heap using Box<dyn Fn>
fn make_multiplier(x: i32) -> Box<dyn Fn(i32) -> i32> {
    Box::new(move |y| x * y)
}

fn apply_twice<F: Fn(i32) -> i32>(f: F, val: i32) -> i32 {
    f(f(val))
}

fn main() {
    let add5  = make_adder(5);
    let triple = make_multiplier(3);

    println!("{}", add5(10));            // 15
    println!("{}", triple(7));           // 21
    println!("{}", apply_twice(add5, 0)); // 10
    println!("{}", apply_twice(|x| x * 2, 3)); // 12
}

When to use impl Fn vs Box<dyn Fn>:

	`impl Fn`	`Box<dyn Fn>`
Storage in struct	❌	✅
Return from function	✅	✅
Runtime cost	Zero	Small heap alloc
Works in collections	❌	✅

17. Unsafe Rust

Rust's safety guarantees are enforced at compile time — but sometimes you need to step outside them. unsafe blocks let you do four things the borrow checker won't normally allow.

What unsafe unlocks:

Dereference raw pointers
Call unsafe functions or C functions
Access or mutate static mutable variables
Implement unsafe traits

fn main() {
    // Raw pointers
    let x = 42;
    let r: *const i32 = &x;           // create raw pointer (safe)

    unsafe {
        println!("{}", *r);            // dereference (unsafe)
    }

    // Mutable raw pointer
    let mut y = 10;
    let rw: *mut i32 = &mut y;
    unsafe {
        *rw += 1;
    }
    println!("{}", y); // 11
}

Unsafe functions:

unsafe fn dangerous_operation(ptr: *mut i32, len: usize) {
    for i in 0..len {
        *ptr.add(i) *= 2;
    }
}

fn main() {
    let mut data = vec![1, 2, 3, 4, 5];
    let ptr = data.as_mut_ptr();
    let len = data.len();

    unsafe {
        dangerous_operation(ptr, len);
    }

    println!("{:?}", data); // [2, 4, 6, 8, 10]
}

Static mutable variables:

static mut COUNTER: u32 = 0;

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

fn main() {
    increment();
    increment();
    unsafe { println!("Counter: {}", COUNTER); } // 2
}

⚠️ unsafe doesn't turn off the borrow checker entirely — it only unlocks those four specific superpowers. You're taking responsibility for ensuring correctness in those blocks. Keep unsafe blocks as small as possible and document why they're safe.

18. FFI — Calling C from Rust

Rust can interoperate with C libraries using its Foreign Function Interface. This is how Rust wraps system APIs, game engines, and existing C codebases.

Calling a C standard library function

use std::ffi::CString;
use std::os::raw::c_char;

extern "C" {
    fn strlen(s: *const c_char) -> usize;
    fn abs(x: i32) -> i32;
}

fn main() {
    // Calling C's abs()
    let result = unsafe { abs(-42) };
    println!("{}", result); // 42

    // Calling C's strlen()
    let s = CString::new("hello").unwrap();
    let len = unsafe { strlen(s.as_ptr()) };
    println!("{}", len); // 5
}

Exposing Rust to C

// lib.rs — compile with: rustc --crate-type=cdylib

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

// main.c — link against the compiled Rust library
extern int add(int a, int b);

int main() {
    printf("%d\n", add(3, 4)); // 7
}

Using `bindgen` for real C libraries

For larger C libraries, use bindgen to auto-generate Rust bindings:

cargo add bindgen --build

// build.rs
fn main() {
    bindgen::Builder::default()
        .header("wrapper.h")
        .generate()
        .unwrap()
        .write_to_file("src/bindings.rs")
        .unwrap();
}

💡 Most real-world FFI is wrapped in a safe Rust API. The unsafe extern calls live in a *-sys crate (e.g. openssl-sys), and a higher-level crate wraps them in a safe interface (e.g. openssl).

Wrapping Up

Here's what Part 3 covered:

Concept	What it gives you
Macros	Compile-time code generation, reduce boilerplate
Modules & Cargo	Code organization, dependency management
Testing	Built-in unit, integration, and doc tests
Higher-order functions	Functional patterns, closures as values
Unsafe Rust	Raw pointers and low-level control when needed
FFI	Interop with C libraries and system APIs

What's in Part 4?

Concurrency with threads and channels
The Send and Sync traits
Mutex, RwLock, and atomics
Building a real CLI tool with clap

If this helped, drop a ❤️ and follow for Part 4!

Advanced Rust Concepts: Iterators, Closures, Generics & More (Part 2)

mihir mohapatra — Tue, 19 May 2026 10:30:04 +0000

This is Part 2 of the Core Rust Concepts series. If you haven't read Part 1, start there — it covers Ownership, Borrowing, Lifetimes, Traits, Result/Option, and Pattern Matching.

Closures
Iterators & Iterator Adaptors
Generics
Enums & the Type System
Smart Pointers
Async / Await

7. Closures

Closures are anonymous functions you can store in variables or pass as arguments. Unlike regular functions, they can capture variables from the surrounding scope.

Rust has three closure traits depending on how they use the environment:

Trait	Captures	Can call
`Fn`	Immutable borrow	Many times
`FnMut`	Mutable borrow	Many times
`FnOnce`	Takes ownership	Once only

fn apply<F: Fn(i32) -> i32>(f: F, val: i32) -> i32 {
    f(val)
}

fn main() {
    let factor = 3;
    let multiply = |x| x * factor; // captures `factor` from scope

    println!("{}", apply(multiply, 5)); // 15

    // FnOnce: consumes the captured value
    let s = String::from("hello");
    let consume = move || println!("{}", s); // takes ownership of s
    consume();
    // consume(); ← error: already moved
}

🦀 Use move before a closure to force it to take ownership of captured variables — common in threads and async code.

8. Iterators & Iterator Adaptors

Rust's iterator system is one of its best features. Iterators are lazy — nothing executes until you call a consumer. You chain adaptor methods and the compiler optimizes the whole pipeline as if you wrote a hand-rolled loop.

fn main() {
    let numbers = vec![1, 2, 3, 4, 5, 6];

    // chain: filter → map → collect
    let result: Vec<i32> = numbers
        .iter()
        .filter(|&&x| x % 2 == 0)  // keep even numbers
        .map(|x| x * 10)            // multiply by 10
        .collect();                 // [20, 40, 60]

    let sum: i32 = (1..=100).sum(); // 5050 — no loop needed!

    // enumerate + take
    for (i, val) in numbers.iter().enumerate().take(3) {
        println!("[{i}] = {val}");
    }
}

Adaptors (lazy — don't run yet):

map, filter, flat_map
take, skip, enumerate
zip, chain, peekable

Consumers (trigger evaluation):

collect, sum, product
count, max, min
find, any, all, fold

💡 Prefer iterator chains over manual for loops — they're often faster, always more expressive, and the compiler can auto-vectorize them.

9. Generics

Generics let you write code that works for any type, with zero runtime overhead. Rust uses monomorphization — at compile time it generates a concrete version for each type you actually use. No boxing, no vtable lookup.

// Generic struct with trait bounds
struct Pair<T> {
    first: T,
    second: T,
}

impl<T: std::fmt::Display + PartialOrd> Pair<T> {
    fn larger(&self) -> &T {
        if self.first > self.second { &self.first }
        else { &self.second }
    }
}

fn main() {
    let nums = Pair { first: 5, second: 10 };
    let strs = Pair { first: "apple", second: "banana" };

    println!("{}", nums.larger());  // 10
    println!("{}", strs.larger()); // "banana"
}

Trait bounds (the T: Display + PartialOrd part) let you constrain what types are allowed. You can also use the where clause for readability:

fn print_larger<T>(a: T, b: T)
where
    T: std::fmt::Display + PartialOrd,
{
    if a > b { println!("{a}") } else { println!("{b}") }
}

10. Enums & the Type System

Rust's enum is far more powerful than in most languages — each variant can hold different data. This makes them algebraic data types, great for modelling state machines, ASTs, or any "one of these shapes" scenario.

enum Shape {
    Circle(f64),                          // radius
    Rectangle(f64, f64),                  // width, height
    Triangle { base: f64, height: f64 },  // named fields
}

impl Shape {
    fn area(&self) -> f64 {
        match self {
            Shape::Circle(r)               => 3.14159 * r * r,
            Shape::Rectangle(w, h)         => w * h,
            Shape::Triangle { base, height } => 0.5 * base * height,
        }
    }
}

fn main() {
    let shapes = vec![
        Shape::Circle(5.0),
        Shape::Rectangle(3.0, 4.0),
        Shape::Triangle { base: 6.0, height: 8.0 },
    ];

    for s in &shapes {
        println!("area: {:.2}", s.area());
    }
}

Output:

area: 78.54
area: 12.00
area: 24.00

Enums + match is how Rust replaces inheritance. No subclassing needed — just model your variants explicitly and let the compiler verify you handle all of them.

11. Smart Pointers

When the ownership rules feel too strict, smart pointers offer controlled escape hatches — each with clearly defined trade-offs.

Type	Purpose	Thread-safe?
`Box<T>`	Heap allocation, single owner	Yes
`Rc<T>`	Shared ownership, ref-counted	No
`Arc<T>`	Shared ownership, atomic ref-count	Yes
`RefCell<T>`	Interior mutability, runtime borrow check	No

use std::rc::Rc;
use std::cell::RefCell;

fn main() {
    // Box: heap-allocate a value
    let boxed = Box::new(42);
    println!("{}", *boxed); // 42

    // Rc: multiple owners (single-threaded)
    let shared = Rc::new(String::from("shared"));
    let clone1 = Rc::clone(&shared);
    println!("ref count: {}", Rc::strong_count(&shared)); // 2
    drop(clone1);
    println!("ref count: {}", Rc::strong_count(&shared)); // 1

    // RefCell: mutate through a shared reference
    let data = RefCell::new(vec![1, 2, 3]);
    data.borrow_mut().push(4);
    println!("{:?}", data.borrow()); // [1, 2, 3, 4]
}

Common pattern — Rc<RefCell<T>> gives you multiple owners that can all mutate the data:

use std::rc::Rc;
use std::cell::RefCell;

let shared_vec = Rc::new(RefCell::new(vec![1, 2]));
let a = Rc::clone(&shared_vec);
let b = Rc::clone(&shared_vec);

a.borrow_mut().push(3);
b.borrow_mut().push(4);

println!("{:?}", shared_vec.borrow()); // [1, 2, 3, 4]

For multi-threaded code, swap Rc → Arc and RefCell → Mutex.

12. Async / Await

Rust's async model is built on futures — values that represent work not yet completed. Marking a function async makes it return a Future. You use .await to yield control until it resolves. A runtime like tokio drives the futures.

# Cargo.toml
[dependencies]
tokio = { version = "1", features = ["full"] }

use tokio::time::{sleep, Duration};

async fn fetch_data(id: u32) -> String {
    sleep(Duration::from_millis(100)).await;
    format!("data for id={id}")
}

#[tokio::main]
async fn main() {
    // Sequential — takes ~200ms
    // let a = fetch_data(1).await;
    // let b = fetch_data(2).await;

    // Concurrent — takes ~100ms
    let (a, b) = tokio::join!(
        fetch_data(1),
        fetch_data(2),
    );

    println!("{}", a);
    println!("{}", b);
}

Key async concepts:

// Spawn a task (like a lightweight thread)
tokio::spawn(async {
    println!("running concurrently");
});

// Select: race multiple futures, use whichever finishes first
tokio::select! {
    result = fetch_data(1) => println!("got: {result}"),
    _ = sleep(Duration::from_secs(1)) => println!("timed out"),
}

💡 Unlike Go or Erlang, Rust async has zero runtime overhead — futures compile down to state machines with no hidden heap allocations per task.

Wrapping Up

Here's a quick summary of what Part 2 covered:

Concept	What it gives you
Closures	Capture-by-reference or by-value anonymous functions
Iterators	Lazy, composable, zero-cost data pipelines
Generics	Monomorphized, compile-time polymorphism
Enums (ADTs)	Model complex state without inheritance
Smart Pointers	Heap, shared ownership, and interior mutability
Async/Await	Non-blocking concurrency with tokio

What's next?

Part 3 will cover:

Macros (macro_rules! and proc macros)
Modules and the Cargo ecosystem
Testing in Rust
Unsafe Rust and FFI

Found this useful? Drop a ❤️ and follow for Part 3!

Core Rust Concepts Every Developer Should Know

mihir mohapatra — Mon, 18 May 2026 09:33:32 +0000

Rust is one of the most loved programming languages — and for good reason. It gives you systems-level control with memory safety guarantees, all enforced at compile time. No garbage collector, no runtime overhead, no segfaults.

This post walks through 6 core concepts you need to understand Rust properly.

Ownership & Move Semantics
Borrowing & References
Lifetimes
Structs & Traits
Error Handling with Result & Option
Pattern Matching

1. Ownership & Move Semantics

Every value in Rust has a single owner. When the owner goes out of scope, the value is automatically dropped — no garbage collector needed. When you assign a value to another variable, ownership moves.

🦀 Rule: Each value has exactly one owner. When the owner is gone, the memory is freed. No dangling pointers, no double-frees.

fn main() {
    let s1 = String::from("hello");
    let s2 = s1;  // s1 is MOVED into s2

    // println!("{}", s1); ← compile error: value moved!
    println!("{}", s2);  // ✓ s2 is the owner now
}

// To copy instead of move, use .clone():
let s3 = s2.clone();
println!("{} {}", s2, s3);  // both are valid

Ownership flow:

s1 owns "hello"  →  move  →  s2 owns "hello"  →  drop  →  s1 is invalid

2. Borrowing & References

Instead of moving, you can borrow a value using a reference (&). Immutable borrows allow many readers simultaneously. Mutable borrows (&mut) are exclusive — you can't have other borrows active at the same time.

The rules:

You can have many immutable references (&T) at once
OR you can have one mutable reference (&mut T) — but not both

fn print_len(s: &String) {        // borrows, does not own
    println!("length: {}", s.len());
}

fn append(s: &mut String) {       // mutable borrow
    s.push_str(" world");
}

fn main() {
    let mut s = String::from("hello");
    print_len(&s);       // s is still valid after this
    append(&mut s);
    println!("{}", s);   // "hello world"
}

3. Lifetimes

Lifetimes are Rust's way of ensuring references never outlive the data they point to. In most cases the compiler infers them, but sometimes you need to annotate explicitly with 'a syntax.

💡 Lifetimes don't change how long data lives — they describe relationships between references so the compiler can verify safety at compile time.

// 'a means: output lives at least as long as both inputs
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

fn main() {
    let s1 = String::from("long string");
    let result;
    {
        let s2 = String::from("xyz");
        result = longest(s1.as_str(), s2.as_str());
        println!("{}", result);  // ✓ both alive here
    }
    // println!("{}", result); ← error: s2 dropped!
}

4. Structs & Traits

Rust uses struct to define custom data types and trait to define shared behavior — similar to interfaces in other languages. A type can implement many traits. The compiler enforces trait contracts statically, with zero runtime overhead.

trait Describe {
    fn describe(&self) -> String;
}

struct Circle { radius: f64 }
struct Rectangle { width: f64, height: f64 }

impl Describe for Circle {
    fn describe(&self) -> String {
        format!("Circle with radius {}", self.radius)
    }
}

impl Describe for Rectangle {
    fn describe(&self) -> String {
        format!("{}×{} rectangle", self.width, self.height)
    }
}

fn print_shape(shape: &impl Describe) {
    println!("{}", shape.describe());
}

fn main() {
    print_shape(&Circle { radius: 3.0 });
    print_shape(&Rectangle { width: 4.0, height: 5.0 });
}

Output:

Circle with radius 3
4×5 rectangle

5. Error Handling with Result & Option

Rust has no exceptions. Instead, functions that can fail return Result<T, E> and functions that may return nothing return Option<T>. The ? operator makes propagating errors ergonomic.

use std::num::ParseIntError;

fn double_parse(s: &str) -> Result<i32, ParseIntError> {
    let n = s.parse::<i32>()?;  // ? returns early on error
    Ok(n * 2)
}

fn main() {
    match double_parse("21") {
        Ok(val)  => println!("Result: {}", val),  // 42
        Err(e)   => println!("Error: {}", e),
    }

    // Option: Some or None
    let items = vec![1, 2, 3];
    if let Some(first) = items.first() {
        println!("first: {}", first);
    }
}

Comparison with other languages:

Language	Error model
Rust	`Result<T, E>` — explicit, compiler-enforced
Go	`(value, error)` — explicit but not enforced
Java/Python	Exceptions — implicit, can be ignored
C	Return codes — easy to ignore

6. Pattern Matching

The match expression is Rust's powerhouse. It's exhaustive — the compiler forces you to handle every case. You can match on values, types, struct fields, ranges, and more, all with destructuring.

enum Command {
    Quit,
    Move { x: i32, y: i32 },
    Print(String),
}

fn handle(cmd: Command) {
    match cmd {
        Command::Quit               => println!("Quit!"),
        Command::Move { x, y }    => println!("Move to ({x},{y})"),
        Command::Print(msg)        => println!("Msg: {msg}"),
    }
}

// Guards and ranges
let score = 85;
let grade = match score {
    90..=100 => "A",
    80..=89  => "B",
    70..=79  => "C",
    _        => "F",
};
println!("Grade: {grade}");

Wrapping Up

These six concepts form the backbone of Rust's unique approach to safe, fast systems programming:

Concept	What it gives you
Ownership	Memory safety without a GC
Borrowing	Share data safely, concurrently
Lifetimes	Compile-time dangling pointer prevention
Traits	Zero-cost polymorphism
Result/Option	Explicit, unignorable error handling
Pattern matching	Exhaustive, expressive control flow

The best way to learn Rust is to fight the borrow checker — every error it throws is teaching you something real about memory. Start with The Rust Book (it's free!) and Rustlings for hands-on exercises.

If this helped you, drop a ❤️ and share with someone learning Rust!

DEV Community: mihir mohapatra

Rust Concepts: Macros, Modules, Testing & Unsafe Rust (Part 3)

Table of Contents

13. Macros

Declarative Macros (macro_rules!)

Procedural Macros (Derive)

14. Modules & the Cargo Ecosystem

Modules

Splitting across files

Cargo — The Build System & Package Manager

15. Testing in Rust

Unit Tests

Integration Tests

Test with Result

16. Closures as Return Types & Higher-Order Functions

17. Unsafe Rust

18. FFI — Calling C from Rust

Calling a C standard library function

Exposing Rust to C

Using bindgen for real C libraries

Wrapping Up

What's in Part 4?

Advanced Rust Concepts: Iterators, Closures, Generics & More (Part 2)

Table of Contents

7. Closures

8. Iterators & Iterator Adaptors

9. Generics

10. Enums & the Type System

11. Smart Pointers

12. Async / Await

Wrapping Up

What's next?

Core Rust Concepts Every Developer Should Know

Table of Contents

1. Ownership & Move Semantics

2. Borrowing & References

3. Lifetimes

4. Structs & Traits

5. Error Handling with Result & Option

6. Pattern Matching

Wrapping Up

Declarative Macros (`macro_rules!`)

Using `bindgen` for real C libraries