Reduce genericity in more iterator closures

src/iter/find.rs

@@ -87,10 +87,14 @@ where
     where
         I: IntoIterator<Item = T>,
     {
+        fn not_full<T>(found: &AtomicBool) -> impl Fn(&T) -> bool + '_ {
+            move |_| !found.load(Ordering::Relaxed)
+        }
+
         self.item = iter
             .into_iter()
             // stop iterating if another thread has found something
-            .take_while(|_| !self.full())
+            .take_while(not_full(&self.found))
             .find(self.find_op);
         if self.item.is_some() {
             self.found.store(true, Ordering::Relaxed)

src/iter/flatten.rs

@@ -35,6 +35,10 @@ where
     where
         C: UnindexedConsumer<Self::Item>,
     {
-        self.base.flat_map(|x| x).drive_unindexed(consumer)
+        fn id<T>(x: T) -> T {
+            x
+        }
+
+        self.base.flat_map(id).drive_unindexed(consumer)
     }
 }

src/iter/fold.rs

@@ -147,11 +147,18 @@ where
     where
         I: IntoIterator<Item = T>,
     {
+        fn not_full<C, ID, T>(base: &C) -> impl Fn(&T) -> bool + '_
+        where
+            C: Folder<ID>,
+        {
+            move |_| !base.full()
+        }
+
         let base = self.base;
         let item = iter
             .into_iter()
             // stop iterating if another thread has finished
-            .take_while(|_| !base.full())
+            .take_while(not_full(&base))
             .fold(self.item, self.fold_op);
 
         FoldFolder {

src/iter/for_each.rs

@@ -52,7 +52,7 @@ where
     where
         I: IntoIterator<Item = T>,
     {
-        iter.into_iter().fold((), |_, item| (self.op)(item));
+        iter.into_iter().for_each(self.op);
         self
     }
 

src/iter/from_par_iter.rs

@@ -1,3 +1,4 @@
+use super::noop::NoopConsumer;
 use super::{FromParallelIterator, IntoParallelIterator, ParallelExtend, ParallelIterator};
 
 use std::borrow::Cow;
@@ -222,6 +223,6 @@ impl FromParallelIterator<()> for () {
     where
         I: IntoParallelIterator<Item = ()>,
     {
-        par_iter.into_par_iter().for_each(|()| {})
+        par_iter.into_par_iter().drive_unindexed(NoopConsumer)
     }
 }

src/iter/interleave.rs

@@ -205,11 +205,14 @@ where
     /// should yield the next element, otherwise, if `j` should yield
     /// the next element, set a = index/2 and b = (index/2)+1
     fn split_at(self, index: usize) -> (Self, Self) {
+        #[inline]
+        fn odd_offset(flag: bool) -> usize {
+            (!flag) as usize
+        }
+
         let even = index % 2 == 0;
         let idx = index >> 1;
 
-        let odd_offset = |flag| if flag { 0 } else { 1 };
-
         // desired split
         let (i_idx, j_idx) = (
             idx + odd_offset(even || self.i_next),

src/iter/map_with.rs

@@ -310,10 +310,15 @@ where
     where
         I: IntoIterator<Item = T>,
     {
+        fn with<'f, T, U, R>(
+            item: &'f mut U,
+            map_op: impl Fn(&mut U, T) -> R + 'f,
+        ) -> impl FnMut(T) -> R + 'f {
+            move |x| map_op(item, x)
+        }
+
         {
-            let map_op = self.map_op;
-            let item = &mut self.item;
-            let mapped_iter = iter.into_iter().map(|x| map_op(item, x));
+            let mapped_iter = iter.into_iter().map(with(&mut self.item, self.map_op));
             self.base = self.base.consume_iter(mapped_iter);
         }
         self