Merge #406

406: Into_group_map_by r=jswrenn a=Sagebati

Add the into_group_map_by , tried with returning an iterator instead of an hashmap, can ben reverted on demand.

Co-authored-by: Samuel Batissou <[email protected]>
Co-authored-by: Samuel Batissou Tiburcio <[email protected]>

Author: bors[bot]

src/group_map.rs

@@ -19,4 +19,16 @@ pub fn into_group_map<I, K, V>(iter: I) -> HashMap<K, Vec<V>>
     }
 
     lookup
-}
+}
+
+pub fn into_group_map_by<I, K, V>(iter: I, f: impl Fn(&V) -> K) -> HashMap<K, Vec<V>>
+    where
+        I: Iterator<Item=V>,
+        K: Hash + Eq,
+{
+    into_group_map(
+        iter.map(|v| (f(&v), v))
+    )
+}
+
+

src/lib.rs

@@ -2328,6 +2328,42 @@ pub trait Itertools : Iterator {
         group_map::into_group_map(self)
     }
 
+
+    /// Return an `Iterator` on a HahMap. Keys mapped to `Vec`s of values. The key is specified in
+    /// in the closure.
+    /// Different of into_group_map_by because the key is still present. It is also more general.
+    /// you can also fold the group_map.
+    ///
+    /// ```
+    /// use itertools::Itertools;
+    /// use std::collections::HashMap;
+    ///
+    /// let data = vec![(0, 10), (2, 12), (3, 13), (0, 20), (3, 33), (2, 42)];
+    /// let lookup: HashMap<u32,Vec<(u32, u32)>> = data.clone().into_iter().into_group_map_by(|a|
+    /// a.0);
+    ///
+    /// assert_eq!(lookup[&0], vec![(0,10),(0,20)]);
+    /// assert_eq!(lookup.get(&1), None);
+    /// assert_eq!(lookup[&2], vec![(2,12), (2,42)]);
+    /// assert_eq!(lookup[&3], vec![(3,13), (3,33)]);
+    ///
+    /// assert_eq!(
+    ///     data.into_iter()
+    ///     .into_group_map_by(|x| x.0)
+    ///     .into_iter()
+    ///     .map(|(key, values)| (key, values.into_iter().fold(0,|acc, (_,v)| acc + v )))
+    ///     .collect::<HashMap<u32,u32>>()[&0], 30)
+    /// ```
+    #[cfg(feature = "use_std")]
+    fn into_group_map_by<K, V, F>(self, f: F) -> HashMap<K, Vec<V>>
+        where
+            Self: Iterator<Item=V> + Sized,
+            K: Hash + Eq,
+            F: Fn(&V) -> K,
+    {
+        group_map::into_group_map_by(self, f)
+    }
+
     /// Return the minimum and maximum elements in the iterator.
     ///
     /// The return type `MinMaxResult` is an enum of three variants: