# Using #[derive(Sum)]

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(),
),
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`).
Deriving `Sum` for enums is not supported.