Introduction to Vectors in Rust

Vectors (Vec<T>) are one of the most commonly used collections in Rust. They provide a dynamic, growable array that stores elements of the same type in contiguous memory. Vectors are heap-allocated and offer flexible sizing while maintaining fast access times.

Key Concepts

• Dynamic Sizing: Grows and shrinks at runtime
• Type Safety: All elements must be the same type
• Memory Contiguous: Elements stored sequentially in memory
• Ownership: Vector owns its elements
• Performance: O(1) index access, amortized O(1) push

1. Creating Vectors

Basic Creation Methods

fn main() { // Method 1: Vec::new() - empty vector let mut v1: Vec<i32> = Vec::new(); v1.push(1); v1.push(2); println!("v1: {:?}", v1); // Method 2: vec! macro - with initial values let v2 = vec![1, 2, 3, 4, 5]; println!("v2: {:?}", v2); // Method 3: vec! macro with repeated value let v3 = vec![0; 10]; // Creates vector with 10 zeros println!("v3: {:?}", v3); // Method 4: From iterator let v4: Vec<i32> = (0..5).collect(); println!("v4: {:?}", v4); // Method 5: From array let arr = [1, 2, 3, 4, 5]; let v5 = Vec::from(arr); println!("v5: {:?}", v5); // Method 6: with_capacity - pre-allocate space let mut v6 = Vec::with_capacity(10); println!("v6 capacity: {}, length: {}", v6.capacity(), v6.len()); // Method 7: From raw parts (advanced, unsafe) let ptr = Box::into_raw(Box::new([1, 2, 3])) as *mut i32; let v7 = unsafe { Vec::from_raw_parts(ptr, 3, 3) }; println!("v7: {:?}", v7); }

Type Annotations

fn main() { // Explicit type annotation let v1: Vec<i32> = Vec::new(); let v2: Vec<&str> = Vec::new(); let v3: Vec<String> = Vec::new(); // Type inference from usage let mut v4 = Vec::new(); v4.push(42); // Now v4 is Vec<i32> let mut v5 = Vec::new(); v5.push("hello"); // Now v5 is Vec<&str> // Using turbofish syntax let v6 = Vec::<i32>::new(); let v7 = vec![1, 2, 3]; // Vec<i32> inferred // Complex types let v8: Vec<Vec<i32>> = vec![ vec![1, 2, 3], vec![4, 5, 6], vec![7, 8, 9], ]; println!("v8: {:?}", v8); }

2. Accessing Elements

Indexing and Safe Access

fn main() { let v = vec![10, 20, 30, 40, 50]; // Direct indexing (panics if out of bounds) let third = v[2]; println!("Third element: {}", third); // Safe access with get() (returns Option) match v.get(2) { Some(value) => println!("Third element safely: {}", value), None => println!("No third element"), } // Safe access to non-existent index match v.get(10) { Some(value) => println!("Element at 10: {}", value), None => println!("No element at index 10"), } // First and last elements if let Some(first) = v.first() { println!("First: {}", first); } if let Some(last) = v.last() { println!("Last: {}", last); } // Getting slices let slice = &v[1..4]; // [20, 30, 40] println!("Slice: {:?}", slice); // Getting mutable references let mut v = vec![1, 2, 3, 4, 5]; if let Some(element) = v.get_mut(2) { *element = 100; } println!("After modification: {:?}", v); }

Multiple Element Access

fn main() { let v = vec![1, 2, 3, 4, 5]; // Get multiple elements let first_two = &v[0..2]; println!("First two: {:?}", first_two); // Get all except first let tail = &v[1..]; println!("Tail: {:?}", tail); // Get all except last let init = &v[..v.len()-1]; println!("Init: {:?}", init); // Split into two at index let (left, right) = v.split_at(3); println!("Left: {:?}, Right: {:?}", left, right); // Chunks let chunks: Vec<&[i32]> = v.chunks(2).collect(); println!("Chunks of 2: {:?}", chunks); // Windows (overlapping chunks) let windows: Vec<&[i32]> = v.windows(3).collect(); println!("Windows of 3: {:?}", windows); }

3. Modifying Vectors

Adding Elements

fn main() { // push - add to end let mut v = Vec::new(); v.push(1); v.push(2); v.push(3); println!("After push: {:?}", v); // insert at position v.insert(1, 10); // Insert 10 at index 1 println!("After insert: {:?}", v); // append - move all elements from another vector let mut v2 = vec![4, 5, 6]; v.append(&mut v2); println!("After append: {:?}, v2 empty: {:?}", v, v2); // extend - add elements from iterator v.extend(vec![7, 8, 9]); println!("After extend: {:?}", v); // extend from slice v.extend_from_slice(&[10, 11, 12]); println!("After extend_from_slice: {:?}", v); // reserve space let mut v = Vec::with_capacity(2); println!("Capacity: {}", v.capacity()); v.reserve(10); // Ensure capacity for at least 10 more println!("Capacity after reserve: {}", v.capacity()); }

Removing Elements

fn main() { let mut v = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; // pop - remove last element if let Some(last) = v.pop() { println!("Popped: {}", last); } println!("After pop: {:?}", v); // remove at index let removed = v.remove(2); // Remove element at index 2 println!("Removed at index 2: {}", removed); println!("After remove: {:?}", v); // remove with swap (doesn't preserve order but O(1)) let mut v = vec![1, 2, 3, 4, 5]; let removed = v.swap_remove(1); // Remove element at index 1, replace with last println!("Swap removed: {}, vector: {:?}", removed, v); // truncate to length let mut v = vec![1, 2, 3, 4, 5]; v.truncate(3); println!("Truncated to 3: {:?}", v); // clear all elements v.clear(); println!("Cleared: {:?}, len: {}", v, v.len()); // drain - remove range let mut v = vec![1, 2, 3, 4, 5]; let drained: Vec<_> = v.drain(1..4).collect(); println!("Drained: {:?}, remaining: {:?}", drained, v); // retain - keep elements satisfying condition let mut v = vec![1, 2, 3, 4, 5, 6]; v.retain(|&x| x % 2 == 0); println!("After retain (evens): {:?}", v); // dedup - remove consecutive duplicates let mut v = vec![1, 1, 2, 2, 3, 1, 1, 4]; v.dedup(); println!("After dedup: {:?}", v); // [1, 2, 3, 1, 4] }

Modifying Elements

fn main() { // Modify by index let mut v = vec![1, 2, 3, 4, 5]; v[2] = 30; println!("After modification: {:?}", v); // Modify using get_mut if let Some(value) = v.get_mut(3) { *value = 40; } println!("After get_mut: {:?}", v); // Swap elements v.swap(0, 4); // Swap first and last println!("After swap: {:?}", v); // Replace with new value, return old let old = std::mem::replace(&mut v[1], 100); println!("Replaced {} with 100, vector: {:?}", old, v); // Update all elements with map in place for x in &mut v { *x *= 2; } println!("After doubling: {:?}", v); // Using resize to change length with default value let mut v = vec![1, 2, 3]; v.resize(5, 0); println!("After resize to 5: {:?}", v); v.resize(2, 0); println!("After resize to 2: {:?}", v); // resize with custom default let mut v = vec!["a", "b", "c"]; v.resize_with(5, || "default"); println!("After resize_with: {:?}", v); }

4. Iterating Over Vectors

Different Iteration Methods

fn main() { let v = vec![10, 20, 30, 40, 50]; // Immutable iteration println!("Immutable iteration:"); for value in &v { print!("{} ", value); } println!(); // Mutable iteration println!("Mutable iteration:"); let mut v = vec![1, 2, 3, 4, 5]; for value in &mut v { *value *= 2; print!("{} ", value); } println!("\nAfter mutation: {:?}", v); // By value (consumes vector) let v = vec![1, 2, 3]; for value in v { print!("{} ", value); } println!(); // println!("{:?}", v); // Error: v moved // With index (enumerate) let v = vec![10, 20, 30]; for (index, value) in v.iter().enumerate() { println!("Index {}: {}", index, value); } // Using iterators explicitly let v = vec![1, 2, 3]; let mut iter = v.iter(); while let Some(value) = iter.next() { println!("Iterator next: {}", value); } }

Functional Iteration

fn main() { let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; // map let doubled: Vec<_> = numbers.iter().map(|&x| x * 2).collect(); println!("Doubled: {:?}", doubled); // filter let evens: Vec<_> = numbers.iter().filter(|&&x| x % 2 == 0).collect(); println!("Evens: {:?}", evens); // filter_map let strings = vec!["1", "2", "abc", "3", "def"]; let parsed: Vec<i32> = strings.iter() .filter_map(|s| s.parse().ok()) .collect(); println!("Parsed numbers: {:?}", parsed); // fold (reduce) let sum = numbers.iter().fold(0, |acc, &x| acc + x); println!("Sum: {}", sum); // any and all let has_even = numbers.iter().any(|&x| x % 2 == 0); let all_positive = numbers.iter().all(|&x| x > 0); println!("Has even: {}, All positive: {}", has_even, all_positive); // find and position if let Some(first_even) = numbers.iter().find(|&&x| x % 2 == 0) { println!("First even: {}", first_even); } if let Some(pos) = numbers.iter().position(|&x| x == 5) { println!("5 at position: {}", pos); } // min and max println!("Min: {:?}", numbers.iter().min()); println!("Max: {:?}", numbers.iter().max()); // chain operations let result: i32 = numbers.iter() .filter(|&&x| x % 2 == 0) .map(|&x| x * x) .take(3) .sum(); println!("Sum of first 3 even squares: {}", result); }

5. Vector Capacity and Performance

Understanding Capacity

fn main() { // Capacity vs length let mut v = Vec::with_capacity(10); println!("Initial - len: {}, cap: {}", v.len(), v.capacity()); for i in 0..5 { v.push(i); println!("After push {} - len: {}, cap: {}", i, v.len(), v.capacity()); } // When capacity is exceeded, vector reallocates for i in 5..15 { v.push(i); println!("After push {} - len: {}, cap: {}", i, v.len(), v.capacity()); } // Shrink to fit v.shrink_to_fit(); println!("After shrink - len: {}, cap: {}", v.len(), v.capacity()); // Reserve additional capacity v.reserve(100); println!("After reserve 100 - cap: {}", v.capacity()); // Reserve exact capacity v.reserve_exact(50); println!("After reserve_exact 50 - cap: {}", v.capacity()); }

Performance Comparisons

use std::time::Instant; fn main() { // Pre-allocation vs dynamic growth const SIZE: usize = 100_000; // Without pre-allocation let start = Instant::now(); let mut v1 = Vec::new(); for i in 0..SIZE { v1.push(i); } println!("Without pre-allocation: {:?}", start.elapsed()); // With pre-allocation let start = Instant::now(); let mut v2 = Vec::with_capacity(SIZE); for i in 0..SIZE { v2.push(i); } println!("With pre-allocation: {:?}", start.elapsed()); // Index access vs get() let v = vec![0; SIZE]; let start = Instant::now(); for i in 0..SIZE { let _ = v[i]; } println!("Direct indexing: {:?}", start.elapsed()); let start = Instant::now(); for i in 0..SIZE { let _ = v.get(i); } println!("get() method: {:?}", start.elapsed()); // Iteration methods let start = Instant::now(); let mut sum = 0; for i in 0..SIZE { sum += v[i]; } println!("Manual index loop: {:?}", start.elapsed()); let start = Instant::now(); let mut sum = 0; for &x in &v { sum += x; } println!("Iterator loop: {:?}", start.elapsed()); }

6. Working with Different Types

Vectors of Custom Types

#[derive(Debug, Clone)] struct Person { name: String, age: u32, } #[derive(Debug)] struct Point { x: f64, y: f64, } impl Point { fn new(x: f64, y: f64) -> Self { Point { x, y } } fn distance(&self, other: &Point) -> f64 { let dx = self.x - other.x; let dy = self.y - other.y; (dx * dx + dy * dy).sqrt() } } fn main() { // Vector of structs let people = vec![ Person { name: "Alice".to_string(), age: 30 }, Person { name: "Bob".to_string(), age: 25 }, Person { name: "Charlie".to_string(), age: 35 }, ]; for person in &people { println!("{:?}", person); } // Vector of Points let points = vec![ Point::new(0.0, 0.0), Point::new(3.0, 4.0), Point::new(1.0, 1.0), ]; let origin = &points[0]; for point in &points[1..] { println!("Distance from origin: {}", origin.distance(point)); } // Sorting custom types (need PartialOrd) let mut people = people; people.sort_by(|a, b| a.age.cmp(&b.age)); println!("Sorted by age: {:?}", people); // Vector of enums (heterogeneous data) #[derive(Debug)] enum Value { Int(i32), Float(f64), Text(String), } let mixed = vec![ Value::Int(42), Value::Float(3.14), Value::Text("hello".to_string()), Value::Int(100), ]; for value in &mixed { match value { Value::Int(x) => println!("Int: {}", x), Value::Float(x) => println!("Float: {}", x), Value::Text(s) => println!("Text: {}", s), } } }

Vectors of References

fn main() { // Vector of references let x = 10; let y = 20; let z = 30; let refs = vec![&x, &y, &z]; for &&val in &refs { println!("Referenced value: {}", val); } // Vector of references to strings let strings = vec![ String::from("hello"), String::from("world"), String::from("!"), ]; let refs: Vec<&String> = strings.iter().collect(); for s in refs { println!("{}", s); } // Vector of boxed values let boxed: Vec<Box<i32>> = vec![Box::new(1), Box::new(2), Box::new(3)]; for b in &boxed { println!("Boxed: {}", **b); } // Vector of trait objects trait Animal { fn speak(&self); } struct Dog; struct Cat; impl Animal for Dog { fn speak(&self) { println!("Woof!"); } } impl Animal for Cat { fn speak(&self) { println!("Meow!"); } } let animals: Vec<Box<dyn Animal>> = vec![ Box::new(Dog), Box::new(Cat), Box::new(Dog), ]; for animal in &animals { animal.speak(); } }

7. Vector Slices and Views

Working with Slices

fn main() { let v = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; // Create slices let slice1 = &v[2..5]; // [3, 4, 5] let slice2 = &v[..4]; // [1, 2, 3, 4] let slice3 = &v[6..]; // [7, 8, 9, 10] let slice4 = &v[..]; // entire vector println!("slice1: {:?}", slice1); println!("slice2: {:?}", slice2); println!("slice3: {:?}", slice3); // Functions that work with slices fn sum_slice(slice: &[i32]) -> i32 { slice.iter().sum() } println!("Sum of slice1: {}", sum_slice(slice1)); println!("Sum of v: {}", sum_slice(&v)); // Mutable slices let mut v = vec![1, 2, 3, 4, 5]; let slice = &mut v[2..4]; slice[0] = 30; slice[1] = 40; println!("Modified v: {:?}", v); // Split into slices let (left, right) = v.split_at_mut(3); left[0] = 10; right[0] = 50; println!("After split: {:?}", v); }

Converting Between Vectors and Slices

fn main() { // Vector to slice let v = vec![1, 2, 3, 4, 5]; let slice: &[i32] = &v; // Slice to vector let arr = [1, 2, 3, 4, 5]; let v_from_slice: Vec<i32> = arr.to_vec(); let v_from_slice2 = Vec::from(&arr[1..4]); println!("v_from_slice: {:?}", v_from_slice); println!("v_from_slice2: {:?}", v_from_slice2); // as_slice and as_mut_slice let mut v = vec![1, 2, 3]; let s = v.as_slice(); println!("as_slice: {:?}", s); let s_mut = v.as_mut_slice(); s_mut[0] = 10; println!("After as_mut_slice: {:?}", v); // Converting between types let v: Vec<i32> = (0..5).collect(); let boxed_slice: Box<[i32]> = v.into_boxed_slice(); let v_back: Vec<i32> = boxed_slice.into_vec(); println!("Back to vector: {:?}", v_back); }

8. Common Vector Operations

Searching and Finding

fn main() { let v = vec![1, 2, 3, 4, 5, 3, 2, 1]; // Contains let has_three = v.contains(&3); println!("Contains 3: {}", has_three); // Find index of first occurrence if let Some(pos) = v.iter().position(|&x| x == 3) { println!("First 3 at position: {}", pos); } // Find index of last occurrence if let Some(pos) = v.iter().rposition(|&x| x == 3) { println!("Last 3 at position: {}", pos); } // Find element if let Some(&element) = v.iter().find(|&&x| x > 3) { println!("First element > 3: {}", element); } // Binary search (requires sorted vector) let mut sorted = v.clone(); sorted.sort(); match sorted.binary_search(&3) { Ok(pos) => println!("3 found at position {} in sorted", pos), Err(pos) => println!("3 not found, would be at position {}", pos), } // Check if all elements satisfy condition let all_positive = v.iter().all(|&x| x > 0); println!("All positive: {}", all_positive); // Check if any element satisfies condition let any_even = v.iter().any(|&x| x % 2 == 0); println!("Any even: {}", any_even); }

Sorting and Ordering

fn main() { let mut numbers = vec![5, 2, 8, 1, 9, 3, 7, 4, 6]; // Sort in ascending order numbers.sort(); println!("Ascending: {:?}", numbers); // Sort in descending order numbers.sort_by(|a, b| b.cmp(a)); println!("Descending: {:?}", numbers); // Sort with custom comparator let mut people = vec![ ("Alice", 30), ("Bob", 25), ("Charlie", 35), ("Alice", 20), ]; people.sort_by(|a, b| { a.0.cmp(&b.0).then(a.1.cmp(&b.1)) }); println!("Sorted people: {:?}", people); // Partial sort (only sort part of the vector) let mut v = vec![5, 2, 8, 1, 9, 3, 7, 4, 6]; v.sort_unstable(); // Faster but doesn't preserve order of equal elements println!("Unstable sort: {:?}", v); // Reverse let mut v = vec![1, 2, 3, 4, 5]; v.reverse(); println!("Reversed: {:?}", v); // Rotate v.rotate_left(2); println!("Rotated left by 2: {:?}", v); v.rotate_right(1); println!("Rotated right by 1: {:?}", v); }

Combining Vectors

fn main() { // Concatenation let v1 = vec![1, 2, 3]; let v2 = vec![4, 5, 6]; // Method 1: extend let mut v3 = v1.clone(); v3.extend(v2.clone()); println!("Extended: {:?}", v3); // Method 2: chain let v4: Vec<_> = v1.iter().chain(v2.iter()).cloned().collect(); println!("Chained: {:?}", v4); // Method 3: append (moves) let mut v5 = v1.clone(); let mut v6 = v2.clone(); v5.append(&mut v6); println!("Appended: {:?}, v6 empty: {:?}", v5, v6); // Join (for vectors of strings) let strings = vec!["hello", "world", "!"]; let joined = strings.join(" "); println!("Joined: '{}'", joined); // Split let numbers = vec![1, 2, 3, 4, 5, 6]; let (first, second): (Vec<_>, Vec<_>) = numbers.iter() .partition(|&&x| x < 4); println!("First partition: {:?}, Second: {:?}", first, second); // Zip let names = vec!["Alice", "Bob", "Charlie"]; let ages = vec![30, 25, 35]; let zipped: Vec<_> = names.iter().zip(ages.iter()).collect(); println!("Zipped: {:?}", zipped); }

9. Advanced Vector Techniques

Vector as Stack

fn main() { let mut stack: Vec<i32> = Vec::new(); // Push onto stack stack.push(1); stack.push(2); stack.push(3); println!("Stack: {:?}", stack); // Pop from stack while let Some(top) = stack.pop() { println!("Popped: {}", top); } // Using as stack with capacity let mut stack = Vec::with_capacity(5); for i in 0..5 { stack.push(i); println!("Push {}, len: {}, cap: {}", i, stack.len(), stack.capacity()); } // Peek at top without popping if let Some(top) = stack.last() { println!("Top: {}", top); } // Stack operations fn evaluate_postfix(expression: &str) -> Option<i32> { let mut stack = Vec::new(); for token in expression.split_whitespace() { match token.parse::<i32>() { Ok(num) => stack.push(num), Err(_) => { let b = stack.pop()?; let a = stack.pop()?; match token { "+" => stack.push(a + b), "-" => stack.push(a - b), "*" => stack.push(a * b), "/" => stack.push(a / b), _ => return None, } } } } stack.pop() } let result = evaluate_postfix("3 4 + 2 *"); println!("Postfix result: {:?}", result); // (3+4)*2 = 14 }

Vector as Queue

use std::collections::VecDeque; fn main() { // VecDeque is better for queue operations let mut queue = VecDeque::new(); // Add to back queue.push_back(1); queue.push_back(2); queue.push_back(3); println!("Queue: {:?}", queue); // Add to front queue.push_front(0); println!("After push_front: {:?}", queue); // Remove from front while let Some(front) = queue.pop_front() { println!("Processing: {}", front); } // Using Vec as queue (less efficient) let mut queue_vec = Vec::new(); queue_vec.push(1); queue_vec.push(2); queue_vec.push(3); while !queue_vec.is_empty() { let front = queue_vec.remove(0); // O(n) operation! println!("Processing (Vec): {}", front); } // Ring buffer with VecDeque let mut buffer = VecDeque::with_capacity(5); for i in 0..10 { if buffer.len() == 5 { buffer.pop_front(); } buffer.push_back(i); println!("Buffer: {:?}", buffer); } }

Matrix Operations with Vectors

#[derive(Debug)] struct Matrix { data: Vec<Vec<i32>>, rows: usize, cols: usize, } impl Matrix { fn new(rows: usize, cols: usize) -> Self { Matrix { data: vec![vec![0; cols]; rows], rows, cols, } } fn from_vec(data: Vec<Vec<i32>>) -> Option<Self> { if data.is_empty() { return None; } let rows = data.len(); let cols = data[0].len(); // Check if all rows have same length if data.iter().any(|row| row.len() != cols) { return None; } Some(Matrix { data, rows, cols, }) } fn get(&self, row: usize, col: usize) -> Option<&i32> { if row < self.rows && col < self.cols { Some(&self.data[row][col]) } else { None } } fn set(&mut self, row: usize, col: usize, value: i32) -> Option<()> { if row < self.rows && col < self.cols { self.data[row][col] = value; Some(()) } else { None } } fn transpose(&self) -> Matrix { let mut result = Matrix::new(self.cols, self.rows); for i in 0..self.rows { for j in 0..self.cols { result.data[j][i] = self.data[i][j]; } } result } fn multiply(&self, other: &Matrix) -> Option<Matrix> { if self.cols != other.rows { return None; } let mut result = Matrix::new(self.rows, other.cols); for i in 0..self.rows { for j in 0..other.cols { let mut sum = 0; for k in 0..self.cols { sum += self.data[i][k] * other.data[k][j]; } result.data[i][j] = sum; } } Some(result) } } fn main() { let mut mat = Matrix::new(3, 3); // Fill matrix for i in 0..3 { for j in 0..3 { mat.set(i, j, (i * 3 + j + 1) as i32).unwrap(); } } println!("Original matrix: {:?}", mat); // Get element if let Some(val) = mat.get(1, 1) { println!("Element at (1,1): {}", val); } // Transpose let transposed = mat.transpose(); println!("Transposed: {:?}", transposed); // Matrix multiplication let mat2 = Matrix::new(3, 3); if let Some(product) = mat.multiply(&mat2) { println!("Product: {:?}", product); } }

10. Error Handling with Vectors

Safe Access Patterns

fn main() { let v = vec![1, 2, 3, 4, 5]; // Safe indexing with match match v.get(10) { Some(value) => println!("Value: {}", value), None => println!("Index out of bounds"), } // Safe indexing with if let if let Some(value) = v.get(2) { println!("Found: {}", value); } // Using unwrap_or for defaults let value = v.get(10).unwrap_or(&-1); println!("Default value: {}", value); // Custom error type #[derive(Debug)] enum VecError { IndexOutOfBounds(usize, usize), EmptyVector, } fn safe_first<T>(v: &[T]) -> Result<&T, VecError> { v.first().ok_or(VecError::EmptyVector) } fn safe_get<T>(v: &[T], index: usize) -> Result<&T, VecError> { v.get(index).ok_or(VecError::IndexOutOfBounds(index, v.len())) } match safe_get(&v, 10) { Ok(val) => println!("Got: {}", val), Err(VecError::IndexOutOfBounds(idx, len)) => { println!("Index {} out of bounds for length {}", idx, len); } Err(VecError::EmptyVector) => println!("Vector is empty"), } // Try operations fn try_operations(v: &[i32]) -> Option<i32> { let first = v.first()?; let last = v.last()?; Some(first + last) } if let Some(sum) = try_operations(&v) { println!("Sum of first and last: {}", sum); } }

Fallible Vector Operations

use std::num::ParseIntError; fn main() { // Collecting Results let strings = vec!["1", "2", "abc", "3", "def"]; // Collect into Result<Vec<i32>, ParseIntError> let parsed: Result<Vec<i32>, ParseIntError> = strings .iter() .map(|s| s.parse::<i32>()) .collect(); match parsed { Ok(numbers) => println!("All parsed: {:?}", numbers), Err(e) => println!("Error parsing: {}", e), } // Filter out errors let successful: Vec<i32> = strings .iter() .filter_map(|s| s.parse().ok()) .collect(); println!("Successful: {:?}", successful); // Partition results let (successes, failures): (Vec<_>, Vec<_>) = strings .iter() .map(|s| s.parse::<i32>()) .partition(Result::is_ok); let successes: Vec<_> = successes.into_iter().map(Result::unwrap).collect(); let failures: Vec<_> = failures.into_iter().map(Result::unwrap_err).collect(); println!("Successes: {:?}", successes); println!("Failures: {:?}", failures); // Try fold for early termination let numbers = vec![1, 2, 3, 4, 5]; let result = numbers.iter().try_fold(0, |acc, &x| { if x == 3 { None } else { Some(acc + x) } }); match result { Some(sum) => println!("Sum until 3: {}", sum), None => println!("Stopped at 3"), } }

11. Parallel Processing with Vectors

Using Rayon for Parallel Iteration

// Add rayon = "1.7" to Cargo.toml use rayon::prelude::*; fn main() { let numbers: Vec<i32> = (0..1_000_000).collect(); // Parallel map let start = std::time::Instant::now(); let squares: Vec<i32> = numbers.par_iter() .map(|&x| x * x) .collect(); println!("Parallel map time: {:?}", start.elapsed()); // Parallel filter let evens: Vec<&i32> = numbers.par_iter() .filter(|&&x| x % 2 == 0) .collect(); println!("Found {} evens", evens.len()); // Parallel fold let sum: i32 = numbers.par_iter() .fold(|| 0, |acc, &x| acc + x) .sum(); println!("Parallel sum: {}", sum); // Parallel any/all let has_negative = numbers.par_iter().any(|&x| x < 0); let all_positive = numbers.par_iter().all(|&x| x >= 0); println!("Has negative: {}, All positive: {}", has_negative, all_positive); // Parallel find if let Some(first_even) = numbers.par_iter().find_first(|&&x| x % 2 == 0) { println!("First even: {}", first_even); } // Parallel sort (rayon doesn't have parallel sort, but we can use par_sort) let mut unsorted: Vec<i32> = (0..100_000).rev().collect(); unsorted.par_sort(); // Uses rayon's parallel sort println!("First few after sort: {:?}", &unsorted[..5]); }

12. Common Patterns and Best Practices

Builder Pattern with Vectors

#[derive(Debug, Clone)] struct QueryBuilder { select: Vec<String>, from: String, where_clauses: Vec<String>, order_by: Vec<(String, bool)>, // (column, ascending) limit: Option<usize>, } impl QueryBuilder { fn new(table: &str) -> Self { QueryBuilder { select: vec!["*".to_string()], from: table.to_string(), where_clauses: Vec::new(), order_by: Vec::new(), limit: None, } } fn select(mut self, columns: Vec<&str>) -> Self { self.select = columns.into_iter().map(String::from).collect(); self } fn and_where(mut self, condition: &str) -> Self { self.where_clauses.push(condition.to_string()); self } fn order_by(mut self, column: &str, ascending: bool) -> Self { self.order_by.push((column.to_string(), ascending)); self } fn limit(mut self, limit: usize) -> Self { self.limit = Some(limit); self } fn build(&self) -> String { let select_str = if self.select.len() == 1 && self.select[0] == "*" { "*".to_string() } else { self.select.join(", ") }; let mut query = format!("SELECT {} FROM {}", select_str, self.from); if !self.where_clauses.is_empty() { query.push_str(" WHERE "); query.push_str(&self.where_clauses.join(" AND ")); } if !self.order_by.is_empty() { let order_str: Vec<String> = self.order_by .iter() .map(|(col, asc)| format!("{} {}", col, if *asc { "ASC" } else { "DESC" })) .collect(); query.push_str(" ORDER BY "); query.push_str(&order_str.join(", ")); } if let Some(limit) = self.limit { query.push_str(&format!(" LIMIT {}", limit)); } query } } fn main() { let query = QueryBuilder::new("users") .select(vec!["id", "name", "email"]) .and_where("age > 18") .and_where("active = true") .order_by("name", true) .limit(10) .build(); println!("{}", query); }

Pool Pattern with Vectors

struct ObjectPool<T> { objects: Vec<T>, max_size: usize, } impl<T> ObjectPool<T> { fn new(max_size: usize) -> Self { ObjectPool { objects: Vec::with_capacity(max_size), max_size, } } fn acquire(&mut self) -> Option<T> { self.objects.pop() } fn release(&mut self, obj: T) -> Result<(), T> { if self.objects.len() < self.max_size { self.objects.push(obj); Ok(()) } else { Err(obj) // Pool full } } fn with_capacity(capacity: usize, f: impl Fn() -> T) -> Self { let mut objects = Vec::with_capacity(capacity); for _ in 0..capacity { objects.push(f()); } ObjectPool { objects, max_size: capacity, } } } #[derive(Debug)] struct Connection { id: usize, connected: bool, } impl Connection { fn new(id: usize) -> Self { Connection { id, connected: true, } } fn query(&self, sql: &str) { println!("Connection {} executing: {}", self.id, sql); } } fn main() { let mut pool = ObjectPool::with_capacity(3, || Connection::new(rand::random())); // Acquire connections if let Some(mut conn) = pool.acquire() { conn.query("SELECT * FROM users"); // Release back to pool let _ = pool.release(conn); } // Pool full example for i in 0..5 { let conn = Connection::new(i); match pool.release(conn) { Ok(()) => println!("Connection {} added to pool", i), Err(conn) => println!("Pool full, connection {} dropped", conn.id), } } }

13. Testing and Documentation

Testing Vector Operations

#[cfg(test)] mod tests { #[test] fn test_vector_creation() { let v1 = vec![1, 2, 3]; assert_eq!(v1.len(), 3); assert_eq!(v1[0], 1); let v2: Vec<i32> = (0..5).collect(); assert_eq!(v2, vec![0, 1, 2, 3, 4]); } #[test] fn test_vector_operations() { let mut v = vec![1, 2, 3]; v.push(4); assert_eq!(v, vec![1, 2, 3, 4]); let last = v.pop(); assert_eq!(last, Some(4)); assert_eq!(v, vec![1, 2, 3]); v.insert(1, 10); assert_eq!(v, vec![1, 10, 2, 3]); } #[test] fn test_vector_iteration() { let v = vec![1, 2, 3]; let sum: i32 = v.iter().sum(); assert_eq!(sum, 6); let doubled: Vec<i32> = v.iter().map(|&x| x * 2).collect(); assert_eq!(doubled, vec![2, 4, 6]); } #[test] #[should_panic(expected = "index out of bounds")] fn test_out_of_bounds() { let v = vec![1, 2, 3]; let _ = v[5]; // This panics } #[test] fn test_safe_access() { let v = vec![1, 2, 3]; assert_eq!(v.get(5), None); assert_eq!(v.get(1), Some(&2)); } }

Documentation Examples

/// A custom vector wrapper with additional functionality /// /// # Examples /// /// ``` /// use mylib::MyVec; /// /// let mut v = MyVec::new(); /// v.push(1); /// v.push(2); /// v.push(3); /// /// assert_eq!(v.sum(), 6); /// assert_eq!(v.average(), 2.0); /// ``` #[derive(Debug, Clone)] pub struct MyVec<T> { data: Vec<T>, } impl<T> MyVec<T> { /// Creates a new empty `MyVec` pub fn new() -> Self { MyVec { data: Vec::new() } } /// Adds an element to the vector /// /// # Examples /// /// ``` /// let mut v = MyVec::new(); /// v.push(42); /// assert_eq!(v.len(), 1); /// ``` pub fn push(&mut self, value: T) { self.data.push(value); } /// Returns the number of elements pub fn len(&self) -> usize { self.data.len() } /// Returns true if the vector is empty pub fn is_empty(&self) -> bool { self.data.is_empty() } } impl MyVec<i32> { /// Returns the sum of all elements /// /// # Panics /// /// Panics if the vector is empty pub fn sum(&self) -> i32 { self.data.iter().sum() } /// Returns the average of all elements /// /// # Panics /// /// Panics if the vector is empty pub fn average(&self) -> f64 { self.sum() as f64 / self.len() as f64 } } impl<T> Default for MyVec<T> { fn default() -> Self { Self::new() } }

Conclusion

Vectors are one of the most versatile and commonly used collections in Rust:

Key Takeaways

1. Dynamic sizing: Vectors grow and shrink at runtime
2. Memory efficient: Elements stored contiguously
3. Fast access: O(1) index access
4. Ownership: Vector owns its elements
5. Rich API: Extensive set of methods for manipulation
6. Performance: Control over capacity for optimization

Common Operations Summary

Operation	Method	Time Complexity
Create empty	Vec::new()	O(1)
Create with values	vec![1, 2, 3]	O(n)
Add to end	push()	O(1) amortized
Remove from end	pop()	O(1)
Insert at index	insert()	O(n)
Remove at index	remove()	O(n)
Get element	get()	O(1)
Iterate	iter()	O(n)
Find element	position()	O(n)
Sort	sort()	O(n log n)

Best Practices

1. Pre-allocate capacity when you know the size in advance
2. Use get() for safe indexing instead of direct indexing
3. Prefer iterators over manual indexing when possible
4. Use Vec::with_capacity() for performance-critical code
5. Consider VecDeque if you need to add/remove from both ends
6. Use shrink_to_fit() to free unused memory
7. Be mindful of ownership when passing vectors to functions

Vectors are fundamental to Rust programming and mastering them is essential for writing efficient and idiomatic Rust code.