# What `#[derive(AddAssign)]` generates

> **NOTE**: `SubAssign`, `BitAndAssign`, `BitOrAssign` and `BitXorAssign` derives
>           are fully equivalent to the `AddAssign` derive described below.

Deriving `AddAssign` works very similar to deriving `Add`. The difference is that
it mutates the existing value in-place instead of creating a new one.




## Structs

The derived `AddAssign` implementation will allow two structs of the same type to
be added together, mutating the first one in-place. This is done by `AddAssign`ing
their respective fields.

```rust
# use derive_more::AddAssign;
#
#[derive(AddAssign)]
struct MyInts(i32, i32);

#[derive(AddAssign)]
struct Point2D {
    x: i32,
    y: i32,
}
```
This generates code equivalent to:
```rust
# use std::ops::AddAssign;
#
# struct MyInts(i32, i32);
#
# struct Point2D {
#     x: i32,
#     y: i32,
# }
#
impl AddAssign for MyInts {
    fn add_assign(&mut self, rhs: Self) {
        match (self, rhs) {
            (Self(self_0, self_1), Self(rhs_0, rhs_1)) => {
                AddAssign::add_assign(self_0, rhs_0);
                AddAssign::add_assign(self_1, rhs_1);
            }
        }
    }
}

impl AddAssign for Point2D {
    fn add_assign(&mut self, rhs: Self) {
        match (self, rhs) {
            (Self { x: self_0, y: self_1 },
             Self { x: rhs_0, y: rhs_1 }) => {
                AddAssign::add_assign(self_0, rhs_0);
                AddAssign::add_assign(self_1, rhs_1);
            }
        }
    }
}
```

The behaviour is similar with more or less fields.


### Ignoring

Sometimes a struct needs to hold a field (most commonly `PhantomData`) that doesn't
participate in `AddAssign` implementation. Such field could be ignored using the
`#[add_assign(skip)]` attribute.

```rust
# use core::marker::PhantomData;
# use derive_more::AddAssign;
#
#[derive(AddAssign)]
struct TupleWithZst<T>(i32, #[add_assign(skip)] PhantomData<T>);

#[derive(AddAssign)]
struct StructWithZst<T> {
    x: i32,
    #[add_assign(skip)] // or #[add_assign(ignore)]
    _marker: PhantomData<T>,
}
```




## Enums

Deriving `AddAssign` is not (yet) supported for enums.

This is mostly due to the fact that it is not trivial convert the `Add`
derivation code, because that returns a `Result<EnumType>` instead of an `EnumType`.
Handling the case where it errors would be hard and maybe impossible.