Add ParallelIterator::collect_vec_list

src/iter/collect/mod.rs

@@ -1,3 +1,5 @@
+use std::collections::LinkedList;
+
 use super::{IndexedParallelIterator, ParallelIterator};
 
 mod consumer;
@@ -64,6 +66,24 @@ where
     });
 }
 
+/// Collects the iterator into a linked list of vectors.
+///
+/// This is called by `ParallelIterator::collect_vec_list`.
+pub(super) fn collect_vec_list<I>(pi: I) -> LinkedList<Vec<I::Item>>
+where
+    I: ParallelIterator,
+{
+    match pi.opt_len() {
+        Some(len) => {
+            // Pseudo-specialization. See impl of ParallelExtend for Vec for more details.
+            let mut v = Vec::new();
+            super::collect::special_extend(pi, len, &mut v);
+            LinkedList::from([v])
+        }
+        None => super::extend::drive_list_vec(pi),
+    }
+}
+
 /// Create a consumer on the slice of memory we are collecting into.
 ///
 /// The consumer needs to be used inside the scope function, and the

src/iter/extend.rs

@@ -12,10 +12,7 @@ use std::hash::{BuildHasher, Hash};
 /// parallel, then extending the collection sequentially.
 macro_rules! extend {
     ($self:ident, $par_iter:ident, $extend:ident) => {
-        $extend(
-            $self,
-            $par_iter.into_par_iter().drive_unindexed(ListVecConsumer),
-        );
+        $extend($self, drive_list_vec($par_iter));
     };
 }
 
@@ -24,6 +21,14 @@ fn len<T>(list: &LinkedList<Vec<T>>) -> usize {
     list.iter().map(Vec::len).sum()
 }
 
+pub(super) fn drive_list_vec<I, T>(pi: I) -> LinkedList<Vec<T>>
+where
+    I: IntoParallelIterator<Item = T>,
+    T: Send,
+{
+    pi.into_par_iter().drive_unindexed(ListVecConsumer)
+}
+
 struct ListVecConsumer;
 
 struct ListVecFolder<T> {

src/iter/mod.rs

@@ -83,6 +83,7 @@ use self::plumbing::*;
 use self::private::Try;
 pub use either::Either;
 use std::cmp::{self, Ordering};
+use std::collections::LinkedList;
 use std::iter::{Product, Sum};
 use std::ops::{Fn, RangeBounds};
 
@@ -2339,6 +2340,41 @@ pub trait ParallelIterator: Sized + Send {
         SkipAnyWhile::new(self, predicate)
     }
 
+    /// Collects this iterator into a linked list of vectors.
+    ///
+    /// This is useful when you need to condense a parallel iterator into a collection,
+    /// but have no specific requirements for what that collection should be. If you
+    /// plan to store the collection longer-term, `Vec<T>` is, as always, likely the
+    /// best default choice, despite the overhead that comes from concatenating each
+    /// vector. Or, if this is an `IndexedParallelIterator`, you should also prefer to
+    /// just collect to a `Vec<T>`.
+    ///
+    /// Internally, most [`FromParallelIterator`]/[`ParallelExtend`] implementations
+    /// use this strategy; each job collecting their chunk of the iterator to a `Vec<T>`
+    /// and those chunks getting merged into a `LinkedList`, before then extending the
+    /// collection with each vector. This is the most efficient way to collect an
+    /// unindexed parallel iterator (again, indexed parallel iterators can be
+    /// efficiently collected simply into a vector).
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use std::collections::LinkedList;
+    /// use rayon::prelude::*;
+    ///
+    /// let result: LinkedList<Vec<_>> = (0..=100)
+    ///     .into_par_iter()
+    ///     .filter(|x| x % 2 == 0)
+    ///     .flat_map(|x| 0..x)
+    ///     .collect_vec_list();
+    ///
+    /// let total_len = result.iter().flatten().count();
+    /// assert_eq!(total_len, 2550);
+    /// ```
+    fn collect_vec_list(self) -> LinkedList<Vec<Self::Item>> {
+        collect::collect_vec_list(self)
+    }
+
     /// Internal method used to define the behavior of this parallel
     /// iterator. You should not need to call this directly.
     ///