Right now, a ballot is HashMap<T, u8>. I'm not sure if this is what I want though. To start with, I probably want to increase the u8 to at least a u16 since it's conceivable that more than 255 people/items might be in contention for some position in some edge cases. More importantly, I'm not sure if a HashMap is the right type of collection. It implies a constraint that T has to have Hash and I don't know how burdensome that is. I know it's a trivial #[derive(Hash)] for basic data like strings but I'd like to see Condorcet being used in more complex applications where one might be voting on complicated data structure representing, say, programs to be run. So I don't know if it would be better for me to implement ballots as a BTree or a Vec of Tuples or something else.

So currently the code is idiomatic Rust where all functions and methods take their arguments by references, e.g.

      pub fn add_ballot(&mut self, ballot: &HashMap<T, u8>) {
          if self.ballots_lock {
              panic!("Attempting to add ballot when ballots are locked")
          }
          for (key, val) in ballot.iter() {
              if self.candidates_lock && !self.candidates.contains(key) {
                  panic!("Ballot contains unauthorized candidate")
              }
          }
          self.ballots.push(ballot.clone())
      }

But as a result of that I have to clone the ballot and later when I calculate the results I have to clone things again:

let mut results: HashMap<T, u8> = candidates.iter().cloned().map(|x| (x, 0)).collect();

It should allow me to get rid of all the cloning if I take ownership of the ballots rather then get them by reference, right? And since they're ballots, it would seem unlikely that anyone would have need of them after the election has been calculated, and if they did, they could always clone a copy themselves. Right? So what do I loose by taking ownership of the ballots and candidates, rather than taking them by reference?