link#

Here’s a comparison of the three iterator reduction methods in Rust:#

Function	Purpose	When to Use	Return Type	Example
`fold(init, f)`	Reduce an iterator using a custom accumulator function.	When you need custom logic, multiple values, or a different output type.	Any type `B` (chosen by you)	`iter.fold(0, \|acc, x\| acc + x)`
`sum()`	Add all elements together.	When you simply want the total of numeric values.	A type implementing `std::iter::Sum` (usually the element type)	`iter.sum::<i32>()`
`product()`	Multiply all elements together.	When you want the product of numeric values.	A type implementing `std::iter::Product` (usually the element type)	`iter.product::<i32>()`

Input Iterator	`fold()`	`sum()`	`product()`
`Iterator<Item = i32>`	`i32`, `f64`, `String`, `(i32, usize)`, `Vec<_>`, `HashMap<_, _>`, etc.	`i32`, `i64`, `f64`, etc.	`i32`, `i64`, `f64`, etc.
`Iterator<Item = &str>`	`String` (concatenation), `usize` (count bytes), etc.	❌ Not supported	❌ Not supported

If you want to…	Use
Add all values	`sum()`
Multiply all values	`product()`
Count while summing	`fold()`
Compute an average (sum and count together)	`fold()`
Build a `String`	`fold()`
Build a `Vec`, `HashMap`, or custom struct	`fold()`
Return a completely different type than the iterator items	`fold()`

Use sum() when your intent is “add everything.”
Use product() when your intent is “multiply everything.”
Use fold() when the computation is anything more general than summing or multiplying, or when the accumulator/result type differs from the iterator’s item type. fold() is the most flexible because it can return any type you define through its initial accumulator and closure.

let nums = [1, 2, 3, 4];

let result: (i32, usize) = nums.iter().fold((0, 0), |(sum, count), &x| {
    (sum + x, count + 1)
});

(i32, usize)

let nums = [1, 2, 3, 4];

let sum: i32 = nums.iter().sum();

i32

let nums = [1, 2, 3, 4];

let product: i32 = nums.iter().product();

i32