alter retain's closure signature from &usize to usize

`retain`'s signature is based on the signature for other collections,
which provide a borrowed value. In our case, an owned usize is more
convenient in many ways and this change provides that.

Matklad pointed out that `vector`'s signature is considered a bug and
`FnMut(&mut T)` is preferred. For mset, which has invariants that must
be enforced at runtime, I don't think we want `retain` to alter the
multiplicity. Instead we go with an owned usize for simplicity and
consistency with the rest of the interface

src/lib.rs

@@ -674,24 +674,24 @@ impl<T: Hash + Eq, S: BuildHasher> MultiSet<T, S> {
     /// Retains only the elements specified by the predicate.
     ///
     /// In other words, remove all pairs `(elem, multiplicty)` such that
-    /// `f(&k, &mut v)` returns `false`.
+    /// `f(&k, usize)` returns `false`.
     ///
     /// # Examples
     ///
     /// ```
     /// use mset::MultiSet;
     ///
     /// let mut mset: MultiSet<_> = vec!['a', 'b', 'c', 'b', 'a'].iter().cloned().collect();
-    /// mset.retain(|_, m: &usize| m % 2 == 0);
+    /// mset.retain(|_, m: usize| m % 2 == 0);
     ///
     /// assert_eq!(mset.elements().len(), 2);
     /// assert_eq!(mset.len(), 4);
     /// ```
     pub fn retain<F>(&mut self, mut f: F)
     where
-        F: FnMut(&T, &usize) -> bool,
+        F: FnMut(&T, usize) -> bool,
     {
-        self.elem_counts.retain(|e, m| f(e, m));
+        self.elem_counts.retain(|e, m| f(e, *m));
     }
 
     /// Clears the multiset, returning all elements in an iterator.