Reduce the genericity of WhileSomeFolder::consume_iter's closure

The `take_while` closure only needs to be generic in `T`, along with a
captured `&AtomicBool`. When we write the closure directly, it carries
all the type baggage of `WhileSomeFolder<'f, C>::consumer_iter<I>`,
where the monomorphized type may explode. Instead, we can move this
closure to a standalone function for reduced genericity.

Author: cuviper

src/iter/while_some.rs

@@ -126,16 +126,19 @@ where
     where
         I: IntoIterator<Item = Option<T>>,
     {
-        let full = self.full;
+        fn some<T>(full: &AtomicBool) -> impl Fn(&Option<T>) -> bool + '_ {
+            move |x| match *x {
+                Some(_) => !full.load(Ordering::Relaxed),
+                None => {
+                    full.store(true, Ordering::Relaxed);
+                    false
+                }
+            }
+        }
+
         self.base = self.base.consume_iter(
             iter.into_iter()
-                .take_while(|x| match *x {
-                    Some(_) => !full.load(Ordering::Relaxed),
-                    None => {
-                        full.store(true, Ordering::Relaxed);
-                        false
-                    }
-                })
+                .take_while(some(self.full))
                 .map(Option::unwrap),
         );
         self

tests/issue671.rs

@@ -0,0 +1,16 @@
+extern crate rayon;
+
+use rayon::prelude::*;
+
+#[test]
+fn type_length_limit() {
+    let _ = Vec::<Result<(), ()>>::new()
+        .into_par_iter()
+        .map(|x| x)
+        .map(|x| x)
+        .map(|x| x)
+        .map(|x| x)
+        .map(|x| x)
+        .map(|x| x)
+        .collect::<Result<(), ()>>();
+}