Merging (not removing) duplicated elements in a vector
Looks pretty good already! Here's some ideas for improvement.

You can make implement Add and AddAssign for Stat so that you can use + and += on those. Here's an AddAssign implementation:

impl std::ops::AddAssign for Stat {
    fn add_assign(&amp;mut self, other: Self) {
        self.points += other.points;
        self.fouls += other.fouls;
    }
}


I like that you reached for a HashMap and fold, those are definitely how I'd do this. However, you only need to store the name and stat (HashMap&lt;String, Stat&gt;), which will make it so you don't have to clone the name each time and also reduce size. You can simply reconstruct the players at the end, before the collection.

Another thing is that you currently perform two lookups in the hashmap for every insertion. The Entry API is a great tool to learn for interacting with maps. It lets you interact with a possibly missing element of the map and only perform one lookup.

Here's a implementation with what I've mentioned so far.

use std::collections::hash_map::Entry;

let dup_merged: Vec&lt;_&gt; = players
    .into_iter()
    .fold(
        HashMap::new(),
        |mut acc: HashMap&lt;String, Stat&gt;, curr: Player| {
            match acc.entry(curr.name) {
                Entry::Occupied(mut occ) =&gt; {
                    // This player already exists, increase its stats
                    *occ.get_mut() += curr.stat;
                }
                Entry::Vacant(vac) =&gt; {
                    // No such player exists, insert these stats
                    vac.insert(curr.stat);
                }
            }
            acc
        },
    )
    .into_iter()
    .map(|(k, v)| Player { name: k, stat: v })
    .collect();


There's another simplification that can be made, due to Stat being a small, cheap struct with sensible default values: You can have Stat implement Default, and then instead of inserting an entry if its missing, you can just have it default to a zero'd Stat and always add:

#[derive(Default, Debug)]
struct Stat {
    points: u32,
    fouls: u32,
}
// ...
let dup_merged: Vec&lt;_&gt; = players
    .into_iter()
    .fold(
        HashMap::new(),
        |mut acc: HashMap&lt;String, Stat&gt;, curr: Player| {
            *acc.entry(curr.name).or_default() += curr.stat;
            acc
        },
    )
    .into_iter()
    .map(|(k, v)| Player { name: k, stat: v })
    .collect();