Rust Collections & Iterators Practice: Vec, HashMap, Iterator Adapters

collect() can build many collection types (Vec, HashSet, String, HashMap, Result<Vec<_>, _>), so the compiler often cannot infer which one you want:

let v = vec![1, 2, 3];

// WRONG: No type hint
// let result = v.iter().map(|x| x * 2).collect();
// error[E0282]: type annotations needed

// RIGHT: Annotate the variable
let result: Vec<i32> = v.iter().map(|x| x * 2).collect();

// RIGHT: Use turbofish
let result = v.iter().map(|x| x * 2).collect::<Vec<_>>();

Turbofish is useful mid-chain. Type annotation is clearer for standalone bindings. Common collect targets:

// Vec
let v = iter.collect::<Vec<_>>();

// HashMap from tuples
let m = pairs.collect::<HashMap<_, _>>();

// Result — collect stops at first Err
let results = items.map(|x| x.parse::<i32>()).collect::<Result<Vec<_>, _>>();

// String — join chars or &strs
let s = chars.collect::<String>();

.iter() yields references. If you collect into a type that expects owned values, the compiler rejects it:

let names = vec![String::from("alice"), String::from("bob")];

// OK: map produces new owned Strings (to_uppercase allocates)
let upper: Vec<String> = names.iter().map(|s| s.to_uppercase()).collect();

// WRONG: collecting &String directly into Vec<String>
// let cloned: Vec<String> = names.iter().collect();
// error[E0277]: a value of type Vec<String> cannot be built from &String

// RIGHT: .cloned() converts &T to T (calls Clone)
let cloned: Vec<String> = names.iter().cloned().collect();

// RIGHT: .into_iter() yields owned values directly
let owned: Vec<String> = names.into_iter().collect();
// names is consumed and can no longer be used

Both convert &T to T, but they work differently:

// copied() — for Copy types (i32, f64, bool, char, etc.)
let nums = vec![1, 2, 3];
let owned: Vec<i32> = nums.iter().copied().collect();

// cloned() — for Clone types that may allocate (String, Vec, etc.)
let names = vec![String::from("alice"), String::from("bob")];
let owned: Vec<String> = names.iter().cloned().collect();

Prefer .copied() when the type is Copy — it documents that the operation is cheap.

The first question to answer when iterating:

let mut v = vec![1, 2, 3];

// Borrow: read only, v survives
for x in v.iter() { println!("{x}"); }

// Mutable borrow: modify in place, v survives
for x in v.iter_mut() { *x += 10; }

// Consume: take ownership, v is gone
for x in v.into_iter() { println!("{x}"); }
// v cannot be used after this point

Start with .iter(). Switch to .into_iter() only when you need ownership or won't use the collection again. Use .iter_mut() when modifying elements in place. Understanding these choices requires a solid grasp of ownership and borrowing -- the same rules that govern &T vs &mut T vs T apply to iterator output.

This appears when you try to take ownership through a borrow:

let names = vec![String::from("alice"), String::from("bob")];

// WRONG: iter() yields &String, but you try to move
// for name in names.iter() {
//     let owned: String = *name;  // error[E0507]
// }

// RIGHT: use into_iter() to take ownership
for name in names.into_iter() {
    let owned: String = name;  // fine — already owned
}

// RIGHT: clone if you need the collection afterward
let names = vec![String::from("alice"), String::from("bob")];
for name in names.iter() {
    let owned: String = name.clone();
}

Iterator adapters are lazy — nothing happens until you consume the iterator with .collect(), .sum(), .for_each(), or a for loop. Each adapter takes a closure, making closures and iterators inseparable in idiomatic Rust:

let v = vec![1, 2, 3, 4, 5];

// filter + map + collect
let doubled_evens: Vec<i32> = v.iter()
    .filter(|&&x| x % 2 == 0)
    .map(|&x| x * 2)
    .collect();
// [4, 8]

// fold for aggregation
let sum: i32 = v.iter().fold(0, |acc, &x| acc + x);

// filter_map combines filter and map in one step
let parsed: Vec<i32> = ["1", "two", "3"].iter()
    .filter_map(|s| s.parse().ok())
    .collect();
// [1, 3]

use std::collections::HashMap;

let mut scores = HashMap::new();
scores.insert("blue", 10);
scores.insert("red", 25);

// Access with get (returns Option<&V>)
let blue_score = scores.get("blue"); // Some(&10)

// Entry API for conditional insert
scores.entry("green").or_insert(50);

// Build from iterator of tuples
let teams = vec![("blue", 10), ("red", 25)];
let scores: HashMap<&str, i32> = teams.into_iter().collect();

Entry API Cookbook

The Entry API avoids double lookups. Three patterns you'll use constantly:

use std::collections::HashMap;
let mut counts: HashMap<&str, i32> = HashMap::new();
let words = vec!["hello", "world", "hello"];

// Counting: increment or initialize to 0
for word in &words {
    *counts.entry(word).or_insert(0) += 1;
}

// Lazy default: only compute if key is missing
let mut cache: HashMap<String, Vec<u8>> = HashMap::new();
let data = cache.entry("key".into())
    .or_insert_with(|| expensive_computation());

// Update-or-insert: modify existing, insert if absent
let mut scores: HashMap<&str, i32> = HashMap::new();
scores.entry("player")
    .and_modify(|s| *s += 10)
    .or_insert(10);

or_insert_with takes a closure — the value is only computed when the key is missing. Use this instead of or_insert when the default is expensive.

HashMap Iteration Order

HashMap uses randomly seeded hashing for DoS resistance, so iteration order can vary between runs. If you need deterministic order:

• Sorted keys: Use BTreeMap (keys iterate in sorted order)
• Insertion order: Use IndexMap from the indexmap crate

In Rust 2018, [1, 2, 3].into_iter() yielded references (&i32) for backwards compatibility. In Rust 2021+, it yields owned values (i32):

// Rust 2021: iterates by value
let arr = [1, 2, 3];
for x in arr.into_iter() {
    // x is i32 (owned)
}

// If you want references explicitly:
for x in arr.iter() {
    // x is &i32
}

If you're reading older code or upgrading editions, watch for this change. cargo fix --edition handles the migration automatically. For a compact reference of all iterator adapters and collection patterns, see the iterators cheat sheet.

• The Rust Book: Iterators — lazy evaluation, consuming adapters
• std::iter::Iterator — full API with collect() guidance
• HashMap docs — entry API, hashing, performance
• Rust Edition Guide: IntoIterator for Arrays — the 2021 behavior change