Using #[derive(Sum)]

• 1 Example usage
• 2 Structs
• 3 Enums

The derived Sum implementation will allow an iterator of your type to be summed together into a new instance of the type with all the fields added together. Apart from the original types requiring an implementation of Sum, it is also required that your type to implements Add. So normally you want to derive that one as well.

All this is also true for the Product, except that then all the fields are multiplied and an implementation of Mul is required. This is usually the easiest to implement by adding #[derive(MulSelf)].

1 Example usage

#[derive(Add, Sum, PartialEq)]
struct MyInts(i32, i64);

fn main() {
    let int_vec = vec![MyInts(2, 3), MyInts(4, 5), MyInts(6, 7)];
    assert!(MyInts(12, 15) == int_vec.into_iter().sum())
}

2 Structs

When deriving Sum for a struct with two fields its like this:

#[derive(Add, Sum)]
struct MyInts(i32, i64);

Code like this will be generated for the Sum implementation:

impl ::core::iter::Sum for MyInts {
    #[inline]
    fn sum<I: ::core::iter::Iterator<Item = Self>>(iter: I) -> Self {
        iter.fold(
            MyInts(
                ::core::iter::empty::<i32>().sum(),
                ::core::iter::empty::<i64>().sum(),
            ),
            ::core::ops::Add::add,
        )
    }
}

The trick here is that we get the identity struct by calling sum on empty iterators. This way we can get the identity for sum (i.e. 0) and the identity for product (i.e. 1).

3 Enums

Deriving Sum for enums is not supported.