count partial duplicates in Vec of structs with a custom function - rust

Question

So let's say I have the following example:
struct Client {
email: String,
phone: String,
details: String
}
fn main() {
let mut clients: Vec<Client> = Vec::new();
clients.push(Client {
email: "john#gmail.com".to_string(),
phone: "0123456789".to_string(),
details: "custom details".to_string(),
});
clients.push(Client {
email: "john#gmail.com".to_string(),
phone: "0123456789".to_string(),
details: "other details".to_string(),
});
clients.push(Client {
email: "james#gmail.com".to_string(),
phone: "9876543210".to_string(),
details: "test".to_string(),
});
}
What would be the best (Rust idiomatic) way to count partial duplicates in this vector by checking email and phone in the Client? For instance - in the example above one duplicate would be found.

Answer 1

One option is to create a HashSet with (email, phone) for each client. As HashSet keep only unique elements, we can get the number of duplicates elements with the difference of the number of elements in clients an in the set:
use std::collections::HashMap;
struct Client {
email: String,
phone: String,
details: String,
}
fn main() {
let mut clients: Vec<Client> = Vec::new();
clients.push(Client {
email: "john#gmail.com".to_string(),
phone: "0123456789".to_string(),
details: "custom details".to_string(),
});
clients.push(Client {
email: "john#gmail.com".to_string(),
phone: "0123456789".to_string(),
details: "other details".to_string(),
});
clients.push(Client {
email: "james#gmail.com".to_string(),
phone: "9876543210".to_string(),
details: "test".to_string(),
});
// use as_str to get a `&str` from a String to avoid copying the string
let uniques: HashMap<_, _> = clients.iter()
.map(|c| (c.email.as_str(), c.phone.as_str()))
.collect();
let num_dups = clients.len() - uniques.len();
assert_eq!(1, num_dups);
}

Answer 2

You will often want to know which were the duplicates. In that case, a straight-forward extension of the HashSet solution can be used:
use std::collections::HashMap;
struct Client {
email: String,
phone: String,
details: String,
}
impl Client {
fn key<'a>(&'a self) -> (&'a str, &'a str) {
(&self.email, &self.phone)
}
}
fn main() {
let clients = vec![Client {
email: "john#gmail.com".to_string(),
phone: "0123456789".to_string(),
details: "custom details".to_string(),
},
Client {
email: "john#gmail.com".to_string(),
phone: "0123456789".to_string(),
details: "other details".to_string(),
},
Client {
email: "james#gmail.com".to_string(),
phone: "9876543210".to_string(),
details: "test".to_string(),
}];
let mut keyed = HashMap::new();
for c in &clients {
keyed.entry(c.key()).or_insert(vec![]).push(c)
}
for (k, v) in &keyed {
if v.len() > 1 {
println!("Key {:?} has {} duplicates!", k, v.len());
}
}
}
Note the use of a method on Client to keep the keying logic in one place, the use of vec![] to reduce the amount of explicit mutability needed, and there's no need to specify the type of clients as it can be inferred.