Using fold but your accumulator starts as the first element anyway? Iterator::reduce cuts out the boilerplate and handles empty iterators gracefully.
The fold pattern you keep writing
When finding the longest string, maximum value, or combining elements, fold forces you to pick an initial value — often awkwardly:
1
2
3
4
5
6
7
| let words = vec!["rust", "is", "awesome"];
let longest = words.iter().fold("", |acc, &w| {
if w.len() > acc.len() { w } else { acc }
});
assert_eq!(longest, "awesome");
|
That empty string "" is a code smell — it’s not a real element, it’s just satisfying fold’s signature. And if the input is empty, you silently get "" back instead of knowing there was nothing to reduce.
Enter reduce
Iterator::reduce uses the first element as the initial accumulator. No seed value needed, and it returns Option<T> — None for empty iterators:
1
2
3
4
5
6
7
| let words = vec!["rust", "is", "awesome"];
let longest = words.iter().reduce(|acc, w| {
if w.len() > acc.len() { w } else { acc }
});
assert_eq!(longest, Some(&"awesome"));
|
The Option return makes the empty case explicit — no more silent defaults.
Finding extremes without max_by
reduce is perfect for custom comparisons where max_by feels heavy:
1
2
3
4
5
6
7
| let scores = vec![("Alice", 92), ("Bob", 87), ("Carol", 95), ("Dave", 88)];
let top_scorer = scores.iter().reduce(|best, current| {
if current.1 > best.1 { current } else { best }
});
assert_eq!(top_scorer, Some(&("Carol", 95)));
|
Concatenating without an allocator seed
Building a combined result from parts? reduce avoids allocating an empty starter:
1
2
3
4
5
6
7
8
9
10
11
12
| let parts = vec![
String::from("hello"),
String::from(" "),
String::from("world"),
];
let combined = parts.into_iter().reduce(|mut acc, s| {
acc.push_str(&s);
acc
});
assert_eq!(combined, Some(String::from("hello world")));
|
Compare this to fold(String::new(), ...) — with reduce, the first String becomes the accumulator directly, saving one allocation.
reduce vs fold — when to use which
Use reduce when the accumulator is the same type as the elements and there’s no meaningful “zero” value. Use fold when you need a different return type or a specific starting value:
1
2
3
4
5
6
7
8
9
10
11
12
13
| // reduce: same type in, same type out
let sum = vec![1, 2, 3, 4].into_iter().reduce(|a, b| a + b);
assert_eq!(sum, Some(10));
// fold: different return type (counting into a HashMap)
use std::collections::HashMap;
let counts = vec!["a", "b", "a", "c", "b", "a"]
.into_iter()
.fold(HashMap::new(), |mut map, item| {
*map.entry(item).or_insert(0) += 1;
map
});
assert_eq!(counts["a"], 3);
|
reduce has been stable since Rust 1.51 — it’s the functional programmer’s best friend for collapsing iterators when the first element is your natural starting point.