New GroupingMap::max[_by[_key]]_in

Author: Philippe-Cholet

src/grouping_map.rs

@@ -281,7 +281,7 @@ where
     where
         V: Ord,
     {
-        self.max_by(|_, v1, v2| V::cmp(v1, v2))
+        self.max_in(HashMap::new())
     }
 
     /// Groups elements from the `GroupingMap` source by key and finds the maximum of each group
@@ -303,14 +303,11 @@ where
     /// assert_eq!(lookup[&2], 5);
     /// assert_eq!(lookup.len(), 3);
     /// ```
-    pub fn max_by<F>(self, mut compare: F) -> HashMap<K, V>
+    pub fn max_by<F>(self, compare: F) -> HashMap<K, V>
     where
         F: FnMut(&K, &V, &V) -> Ordering,
     {
-        self.reduce(|acc, key, val| match compare(key, &acc, &val) {
-            Ordering::Less | Ordering::Equal => val,
-            Ordering::Greater => acc,
-        })
+        self.max_by_in(compare, HashMap::new())
     }
 
     /// Groups elements from the `GroupingMap` source by key and finds the element of each group
@@ -332,12 +329,12 @@ where
     /// assert_eq!(lookup[&2], 5);
     /// assert_eq!(lookup.len(), 3);
     /// ```
-    pub fn max_by_key<F, CK>(self, mut f: F) -> HashMap<K, V>
+    pub fn max_by_key<F, CK>(self, f: F) -> HashMap<K, V>
     where
         F: FnMut(&K, &V) -> CK,
         CK: Ord,
     {
-        self.max_by(|key, v1, v2| f(key, v1).cmp(&f(key, v2)))
+        self.max_by_key_in(f, HashMap::new())
     }
 
     /// Groups elements from the `GroupingMap` source by key and finds the minimum of each group.
@@ -674,4 +671,41 @@ where
 
         map
     }
+
+    /// Apply [`max`](Self::max) with a provided empty map
+    /// (`BTreeMap` or `HashMap` with any hasher).
+    pub fn max_in<M>(self, map: M) -> M
+    where
+        V: Ord,
+        M: Map<Key = K, Value = V>,
+    {
+        self.max_by_in(|_, v1, v2| V::cmp(v1, v2), map)
+    }
+
+    /// Apply [`max_by`](Self::max_by) with a provided empty map
+    /// (`BTreeMap` or `HashMap` with any hasher).
+    pub fn max_by_in<F, M>(self, mut compare: F, map: M) -> M
+    where
+        F: FnMut(&K, &V, &V) -> Ordering,
+        M: Map<Key = K, Value = V>,
+    {
+        self.reduce_in(
+            |acc, key, val| match compare(key, &acc, &val) {
+                Ordering::Less | Ordering::Equal => val,
+                Ordering::Greater => acc,
+            },
+            map,
+        )
+    }
+
+    /// Apply [`max_by_key`](Self::max_by_key) with a provided empty map
+    /// (`BTreeMap` or `HashMap` with any hasher).
+    pub fn max_by_key_in<F, CK, M>(self, mut f: F, map: M) -> M
+    where
+        F: FnMut(&K, &V) -> CK,
+        CK: Ord,
+        M: Map<Key = K, Value = V>,
+    {
+        self.max_by_in(|key, v1, v2| f(key, v1).cmp(&f(key, v2)), map)
+    }
 }