How to sum the values in an array, slice, or Vec in Rust?

In Rust, there are several common ways to sum values within arrays, slices, or Vecs (vectors). Here are some specific examples:

1. Using iterators and the sum method

For arrays, slices, or Vecs, you can use iterators to iterate over each element and apply the sum method to compute the total. This is a very concise and idiomatic Rust approach.

rust
fn main() {
    let arr = [1, 2, 3, 4, 5];
    let sum: i32 = arr.iter().sum();
    println!("The sum is: {}", sum);

    let vec = vec![1, 2, 3, 4, 5];
    let sum: i32 = vec.iter().sum();
    println!("The sum is: {}", sum);

    let slice = &arr[1..4]; // Slice [2, 3, 4]
    let sum: i32 = slice.iter().sum();
    println!("The sum is: {}", sum);
}

2. Using for loops for manual summation

Although using iterators with the sum method is more concise, in certain cases, manually iterating over arrays or Vecs for summation can provide greater control, such as when additional operations are needed during the summation process.

rust
fn main() {
    let arr = [1, 2, 3, 4, 5];
    let mut sum = 0;
    for &item in arr.iter() {
        sum += item;
    }
    println!("The sum is: {}", sum);

    let vec = vec![1, 2, 3, 4, 5];
    let mut sum = 0;
    for item in &vec {
        sum += *item;
    }
    println!("The sum is: {}", sum);

    let slice = &arr[1..4]; // Slice [2, 3, 4]
    let mut sum = 0;
    for &item in slice.iter() {
        sum += item;
    }
    println!("The sum is: {}", sum);
}

3. Using the fold method

The fold method is another flexible way to accumulate values, providing an initial value and allowing for more complex operations during the accumulation process.

rust
fn main() {
    let vec = vec![1, 2, 3, 4, 5];
    let sum: i32 = vec.iter().fold(0, |acc, &x| acc + x);
    println!("The sum is: {}", sum);
}

All three methods have their uses, and the choice depends on personal preference and specific scenario requirements. In most cases, using iterators with the sum method is the simplest and most direct approach.