type MapForGrouping<...> = MapSpecialCase<...>

src/adaptors/map.rs

@@ -4,8 +4,8 @@ use std::marker::PhantomData;
 #[derive(Clone, Debug)]
 #[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
 pub struct MapSpecialCase<I, F> {
-    iter: I,
-    f: F,
+    pub(crate) iter: I,
+    pub(crate) f: F,
 }
 
 pub trait MapSpecialCaseFn<T> {

src/adaptors/mod.rs

@@ -5,7 +5,7 @@
 //! except according to those terms.
 
 mod coalesce;
-mod map;
+pub(crate) mod map;
 mod multi_product;
 pub use self::coalesce::*;
 #[allow(deprecated)]

src/grouping_map.rs

@@ -1,45 +1,39 @@
 #![cfg(feature = "use_std")]
 
-use crate::MinMaxResult;
+use crate::{
+    adaptors::map::{MapSpecialCase, MapSpecialCaseFn},
+    MinMaxResult,
+};
 use std::cmp::Ordering;
 use std::collections::HashMap;
-use std::fmt;
 use std::hash::Hash;
 use std::iter::Iterator;
 use std::ops::{Add, Mul};
 
 /// A wrapper to allow for an easy [`into_grouping_map_by`](crate::Itertools::into_grouping_map_by)
+pub type MapForGrouping<I, F> = MapSpecialCase<I, GroupingMapFn<F>>;
+
 #[derive(Clone)]
-pub struct MapForGrouping<I, F>(I, F);
+pub struct GroupingMapFn<F>(F);
 
-impl<I: fmt::Debug, F> fmt::Debug for MapForGrouping<I, F> {
-    debug_fmt_fields!(MapForGrouping, 0);
+impl<F> std::fmt::Debug for GroupingMapFn<F> {
+    debug_fmt_fields!(GroupingMapFn,);
 }
 
-impl<I, F> MapForGrouping<I, F> {
-    pub(crate) fn new(iter: I, key_mapper: F) -> Self {
-        Self(iter, key_mapper)
+impl<V, K, F: FnMut(&V) -> K> MapSpecialCaseFn<V> for GroupingMapFn<F> {
+    type Out = (K, V);
+    fn call(&mut self, v: V) -> Self::Out {
+        ((self.0)(&v), v)
     }
 }
 
-#[allow(clippy::missing_trait_methods)]
-impl<K, V, I, F> Iterator for MapForGrouping<I, F>
-where
-    I: Iterator<Item = V>,
-    K: Hash + Eq,
-    F: FnMut(&V) -> K,
-{
-    type Item = (K, V);
-    fn next(&mut self) -> Option<Self::Item> {
-        self.0.next().map(|val| ((self.1)(&val), val))
-    }
-
-    fn fold<B, G>(self, init: B, f: G) -> B
-    where
-        G: FnMut(B, Self::Item) -> B,
-    {
-        let mut key_mapper = self.1;
-        self.0.map(|val| (key_mapper(&val), val)).fold(init, f)
+pub(crate) fn new_map_for_grouping<K, I: Iterator, F: FnMut(&I::Item) -> K>(
+    iter: I,
+    key_mapper: F,
+) -> MapForGrouping<I, F> {
+    MapSpecialCase {
+        iter,
+        f: GroupingMapFn(key_mapper),
     }
 }
 

src/lib.rs

@@ -3194,7 +3194,7 @@ pub trait Itertools: Iterator {
         K: Hash + Eq,
         F: FnMut(&V) -> K,
     {
-        grouping_map::new(grouping_map::MapForGrouping::new(self, key_mapper))
+        grouping_map::new(grouping_map::new_map_for_grouping(self, key_mapper))
     }
 
     /// Return all minimum elements of an iterator.