use size hints for comparing maps

Author: knickish

benchmarks/benches/basic.rs

@@ -38,7 +38,7 @@ fn bench_basic_generation(c: &mut Criterion) {
         b.iter(|| {
             let diff = black_box(StructDiff::diff_ref(&first, &second));
             black_box(diff);
-        })       
+        })
     });
     group.finish();
 }
@@ -47,7 +47,7 @@ fn bench_basic_full(c: &mut Criterion) {
     const GROUP_NAME: &str = "bench_basic";
     let mut rng = WyRand::new_seed(SEED);
     let mut first = black_box(TestBench::generate_random(&mut rng));
-    
+
     let second = black_box(TestBench::generate_random(&mut rng));
     let mut diff: Vec<<TestBench as StructDiff>::Diff> = Vec::new();
     let mut group = c.benchmark_group(GROUP_NAME);
@@ -58,7 +58,7 @@ fn bench_basic_full(c: &mut Criterion) {
         b.iter(|| {
             diff = black_box(StructDiff::diff(&first, &second));
             black_box(first.apply_mut(diff.clone()));
-        })       
+        })
     });
     group.finish();
     first.assert_eq(second, &diff);

benchmarks/src/lib.rs

@@ -95,8 +95,8 @@ impl TestBench {
         assert_eq_unordered_sort!(self.d, right.d, "{:?}", diff);
         assert_eq_unordered_sort!(
             self.e.iter().map(|x| x.0).collect::<Vec<_>>(),
-            right.e.iter().map(|x| x.0).collect::<Vec<_>>(), 
-            "{:?}", 
+            right.e.iter().map(|x| x.0).collect::<Vec<_>>(),
+            "{:?}",
             diff
         );
         assert_eq_unordered_sort!(self.f, right.f, "{:?}", diff);

src/collections/unordered_array_like.rs

@@ -85,14 +85,10 @@ impl<'a, T: Clone + 'a> From<UnorderedArrayLikeDiff<&'a T>> for UnorderedArrayLi
     }
 }
 
-fn collect_into_map<
-    'a,
-    T: Hash + PartialEq + Eq + 'a,
-    B: Iterator<Item = T> + ExactSizeIterator,
->(
+fn collect_into_map<'a, T: Hash + PartialEq + Eq + 'a, B: Iterator<Item = T>>(
     list: B,
 ) -> HashMap<T, usize> {
-    let mut map: HashMap<T, usize> = HashMap::with_capacity(list.len());
+    let mut map: HashMap<T, usize> = HashMap::with_capacity(list.size_hint().1.unwrap_or_default());
     for item in list {
         match map.get_mut(&item) {
             Some(count) => *count += 1,
@@ -149,7 +145,7 @@ pub fn unordered_hashcmp<
     'a,
     #[cfg(feature = "nanoserde")] T: Hash + Clone + PartialEq + Eq + SerBin + DeBin + 'a,
     #[cfg(not(feature = "nanoserde"))] T: Hash + Clone + PartialEq + Eq + 'a,
-    B: Iterator<Item = &'a T> + ExactSizeIterator,
+    B: Iterator<Item = &'a T>,
 >(
     previous: B,
     current: B,
@@ -168,7 +164,8 @@ pub fn unordered_hashcmp<
         ));
     }
 
-    let mut ret: Vec<UnorderedArrayLikeChange<&T>> = vec![];
+    let mut ret: Vec<UnorderedArrayLikeChange<&T>> =
+        Vec::with_capacity((previous.len() + current.len()) >> 1);
 
     for (k, current_count) in current.iter() {
         match previous.remove(k) {
@@ -207,6 +204,8 @@ pub fn unordered_hashcmp<
         ret.push(UnorderedArrayLikeChange::new(k, v, InsertOrRemove::Remove))
     }
 
+    ret.shrink_to_fit();
+
     match ret.is_empty() {
         true => None,
         false => Some(UnorderedArrayLikeDiff(

src/collections/unordered_map_like.rs

@@ -111,7 +111,8 @@ fn collect_into_key_eq_map<
 >(
     list: B,
 ) -> HashMap<&'a K, (&'a V, usize)> {
-    let mut map: HashMap<&K, (&V, usize)> = HashMap::new();
+    let mut map: HashMap<&K, (&V, usize)> =
+        HashMap::with_capacity(list.size_hint().1.unwrap_or_default());
     for (key, value) in list {
         match map.get_mut(&key) {
             Some((_, count)) => *count += 1,
@@ -225,7 +226,8 @@ pub fn unordered_hashcmp<
         )));
     }
 
-    let mut ret: Vec<UnorderedMapLikeChange<&'a K, &'a V>> = vec![];
+    let mut ret: Vec<UnorderedMapLikeChange<&'a K, &'a V>> =
+        Vec::with_capacity((previous.len() + current.len()) >> 1);
 
     for (&k, &(v, current_count)) in current.iter() {
         match previous.remove(&k) {
@@ -283,6 +285,8 @@ pub fn unordered_hashcmp<
         ))
     }
 
+    ret.shrink_to_fit();
+
     match ret.is_empty() {
         true => None,
         false => Some(UnorderedMapLikeDiff(UnorderedMapLikeDiffInternal::Modify(

src/collections/unordered_map_like_recursive.rs

@@ -110,7 +110,7 @@ fn collect_into_key_eq_map<
 >(
     list: B,
 ) -> HashMap<&'a K, &'a V> {
-    let mut map: HashMap<&K, &V> = HashMap::new();
+    let mut map: HashMap<&K, &V> = HashMap::with_capacity(list.size_hint().1.unwrap_or_default());
     for (key, value) in list {
         map.insert(key, value);
     }
@@ -170,7 +170,8 @@ pub fn unordered_hashcmp<
             ));
         }
 
-        let mut ret: Vec<UnorderedMapLikeRecursiveChangeRef<'a, K, V>> = vec![];
+        let mut ret: Vec<UnorderedMapLikeRecursiveChangeRef<'a, K, V>> =
+            Vec::with_capacity((previous.len() + current.len()) >> 1);
 
         for prev_entry in previous.into_iter() {
             if current.remove_entry(prev_entry.0).is_none() {
@@ -188,6 +189,8 @@ pub fn unordered_hashcmp<
             ))
         }
 
+        ret.shrink_to_fit();
+
         match ret.is_empty() {
             true => None,
             false => Some(UnorderedMapLikeRecursiveDiffRef(
@@ -203,7 +206,8 @@ pub fn unordered_hashcmp<
             ));
         }
 
-        let mut ret: Vec<UnorderedMapLikeRecursiveChangeRef<'a, K, V>> = vec![];
+        let mut ret: Vec<UnorderedMapLikeRecursiveChangeRef<'a, K, V>> =
+            Vec::with_capacity((previous.len() + current.len()) >> 1);
 
         for prev_entry in previous.into_iter() {
             match current.remove_entry(prev_entry.0) {
@@ -228,6 +232,8 @@ pub fn unordered_hashcmp<
             ))
         }
 
+        ret.shrink_to_fit();
+
         match ret.is_empty() {
             true => None,
             false => Some(UnorderedMapLikeRecursiveDiffRef(
@@ -245,7 +251,7 @@ pub fn apply_unordered_hashdiffs<
 >(
     list: B,
     diffs: UnorderedMapLikeRecursiveDiffOwned<K, V>,
-) -> Box<dyn Iterator<Item = (K, V)>> {
+) -> Box<dyn ExactSizeIterator<Item = (K, V)>> {
     let diffs = match diffs {
         UnorderedMapLikeRecursiveDiffOwned(
             UnorderedMapLikeRecursiveDiffInternalOwned::Replace(replacement),