DEV Community: mihir mohapatra

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

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