Rust Notes — Module 5

Sun, 22 Mar 2026 00:00:00 +0000

Rust Notes — Module 5: Generics, Closures & Iterators

1. Generics

Generics let you write code that works for any type, with the compiler generating specialized versions at compile time. Zero runtime overhead — same as C++ templates.

Generic Functions

// T is a type parameter — placeholder for any concrete type
fn largest<T: PartialOrd>(list: &[T]) -> &T {
 let mut largest = &list[0];
 for item in list {
 if item > largest {
 largest = item;
 }
 }
 largest
}

// works for any type that implements PartialOrd
let nums = vec![1, 5, 3, 2];
let chars = vec!['a', 'z', 'm'];
println!("{}", largest(&nums)); // 5
println!("{}", largest(&chars)); // z

Generic Structs

struct Stack<T> {
 elements: Vec<T>,
}

// impl block also needs <T>
impl<T> Stack<T> {
 fn new() -> Self {
 Stack { elements: Vec::new() }
 }

 fn push(&mut self, item: T) {
 self.elements.push(item);
 }

 fn pop(&mut self) -> Option<T> {
 self.elements.pop()
 }

 fn peek(&self) -> Option<&T> {
 self.elements.last()
 }

 fn is_empty(&self) -> bool {
 self.elements.is_empty()
 }
}

// type parameter inferred from usage
let mut int_stack = Stack::new();
int_stack.push(1);
int_stack.push(2);

// or explicit
let mut move_stack: Stack<Move> = Stack::new();

Generic Enums

You’ve already used these — Option<T> and Result<T, E> are generic enums:

Closures on Sanketh's Blog

Rust Notes — Module 5

Rust Notes — Module 5: Generics, Closures & Iterators

1. Generics

Generic Functions

Generic Structs

Generic Enums