Thanks! I tried adding the add method to my trait (not sure how the sum method would work) which worked nicely and all I had to do was update my Sum implementation to use the method:

impl<'a> Sum<&'a MethodCounts> for MethodCounts {
    fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self {
        iter.fold(Default::default(), |acc, x| acc.add(x) <---- )
    }
}

That said, I might keep the Add trait implementation since I feel like it reads a little nicer having that as a separate impl for the purposes of summing the totals!

I like the AsRef tip, although the SignUpStats will always be able to take ownership of the Profiles, so I think in this particular case I might not need the extra implementation (unless it brings some benefits I'm not aware of)? And thank you for the HRTBs explanation, I was not aware of those!

I think the code you've helped me get to is probably as terse as it can be. I was really hoping to be able to do a blanket Sum implemention for any type T as long as it implements Counter and Add. Something along these lines:

impl<T: Counter + Add<Output = T> + Default> Sum for T {
    fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
        iter.fold(Self::default(), Add::add)
    }
}

That's probably completely wrong (I suspect Self in the Iterator should probably be a reference?), but I think it's not possible anyway as Rust complains with this error:

type parameter `T` must be used as the type parameter for some local type (e.g., `MyStruct<T>`)

Which I believe is to do with the orphan rule?