V4 par extend

Cargo.toml

@@ -12,7 +12,7 @@ categories = ["concurrency", "algorithms"]
 
 [dependencies]
 orx-pinned-vec = { version = "3.23.0", default-features = false }
-orx-fixed-vec = { version = "3.23.0", default-features = false }
+orx-fixed-vec = { version = "3.24.0", default-features = false }
 orx-split-vec = { version = "3.23.0", default-features = false }
 orx-concurrent-iter = { version = "3.3.0", default-features = false }
 orx-concurrent-bag = { version = "3.4.0", default-features = false }

src/collectables/alg/merge_collected/merge_arbitrary_into.rs

@@ -1,37 +1,16 @@
 use alloc::vec::Vec;
 use orx_split_vec::{Growth, SplitVec};
 
-pub fn merge_arb_into_first_vec<T>(results: Vec<Vec<T>>) -> Vec<T> {
-    let total_len: usize = results.iter().map(|x| x.len()).sum();
-    let mut results = results.into_iter();
-    match results.next() {
-        None => Default::default(),
-        Some(mut result) => {
-            let additional = total_len - result.len();
-            result.reserve(additional);
-            for vec in results {
-                result.extend(vec);
-            }
-            result
-        }
-    }
-}
-
-pub fn merge_arb_into_vec<T>(results: Vec<Vec<T>>, mut dst: Vec<T>) -> Vec<T> {
+pub fn merge_arb_into_vec<T>(results: Vec<Vec<T>>, dst: &mut Vec<T>) {
     let total_len: usize = results.iter().map(|x| x.len()).sum();
     dst.reserve(total_len);
     for vec in results {
         dst.extend(vec);
     }
-    dst
 }
 
-pub fn merge_arb_into_split_vec<T, G: Growth>(
-    results: Vec<Vec<T>>,
-    mut dst: SplitVec<T, G>,
-) -> SplitVec<T, G> {
+pub fn merge_arb_into_split_vec<T, G: Growth>(results: Vec<Vec<T>>, dst: &mut SplitVec<T, G>) {
     for vec in results {
         dst.extend(vec);
     }
-    dst
 }

src/collectables/alg/merge_collected/merge_ordered_into.rs

@@ -22,9 +22,8 @@ impl VecPos {
 // vec
 
 // TODO: performance: this method can be parallelized by pairwise merging
-pub fn merge_ord_into_vec<T>(mut results: Vec<ValsAndIdx<T>>, dst: Option<Vec<T>>) -> Vec<T> {
+pub fn merge_ord_into_vec<T>(mut results: Vec<ValsAndIdx<T>>, dst: &mut Vec<T>) {
     let collected_len: usize = results.iter().map(|x| x.values.len()).sum();
-    let mut dst = dst.unwrap_or_else(|| Vec::with_capacity(collected_len));
     dst.reserve(collected_len);
     let initial_len = dst.len();
     let total_len = initial_len + collected_len;
@@ -63,19 +62,15 @@ pub fn merge_ord_into_vec<T>(mut results: Vec<ValsAndIdx<T>>, dst: Option<Vec<T>
     }
 
     unsafe { dst.set_len(total_len) };
-
-    dst
 }
 
 // splitvec
 
 // TODO: performance: this method can be parallelized by pairwise merging
 pub fn merge_ord_into_split_vec<T, G: Growth + PseudoDefault>(
     mut results: Vec<ValsAndIdx<T>>,
-    dst: Option<SplitVec<T, G>>,
-) -> SplitVec<T, G> {
-    let mut dst = dst.unwrap_or_else(|| PseudoDefault::pseudo_default());
-
+    dst: &mut SplitVec<T, G>,
+) {
     let mut queue = BinaryHeap::with_capacity(results.len());
     let mut pos_indices = vec![0; results.len()];
 
@@ -105,6 +100,4 @@ pub fn merge_ord_into_split_vec<T, G: Growth + PseudoDefault>(
         // allocation within vec.capacity() will still be reclaimed; however, as uninitialized memory
         unsafe { vec.values.set_len(0) };
     }
-
-    dst
 }

src/collectables/alg/merge_collected/mod.rs

@@ -1,7 +1,5 @@
 mod merge_arbitrary_into;
 mod merge_ordered_into;
 
-pub use merge_arbitrary_into::{
-    merge_arb_into_first_vec, merge_arb_into_split_vec, merge_arb_into_vec,
-};
+pub use merge_arbitrary_into::{merge_arb_into_split_vec, merge_arb_into_vec};
 pub use merge_ordered_into::{merge_ord_into_split_vec, merge_ord_into_vec};

src/collectables/col_into_inf.rs

@@ -1,25 +1,3 @@
-use crate::infallible::{Par, Xap};
-use crate::runner::ParRunner;
-use orx_concurrent_iter::ConcurrentIter;
-
 pub trait ColIntoInf<T>: Sized {
     // fn empty(exact_len: Option<usize>) -> Self;
-
-    fn inf_col_into<I, X, R>(dst: Option<Self>, par: Par<I, X, R>) -> Self
-    where
-        I: ConcurrentIter,
-        X: Xap<I = I::Item, O = T>,
-        R: ParRunner,
-        T: Send;
-
-    fn inf_arb_col_into<I, X, R>(
-        dst: Option<Self>,
-        par: Par<I, X, R>,
-        exact_len: Option<usize>,
-    ) -> Self
-    where
-        I: ConcurrentIter,
-        X: Xap<I = I::Item, O = T>,
-        R: ParRunner,
-        T: Send;
 }

src/collectables/inf/col_into_inf.rs

@@ -3,14 +3,16 @@ use crate::runner::ParRunner;
 use orx_concurrent_iter::ConcurrentIter;
 
 pub trait ColIntoInf<T>: Sized {
-    fn inf_col_into<I, X, R>(dst: Option<Self>, par: ParIter<I, X, R>) -> Self
+    fn new_empty() -> Self;
+
+    fn inf_col_into<I, X, R>(dst: &mut Self, par: ParIter<I, X, R>)
     where
         I: ConcurrentIter,
         X: Xap<I = I::Item, O = T>,
         R: ParRunner,
         T: Send;
 
-    fn inf_arb_col_into<I, X, R>(dst: Option<Self>, par: ParIter<I, X, R>) -> Self
+    fn inf_arb_col_into<I, X, R>(dst: &mut Self, par: ParIter<I, X, R>)
     where
         I: ConcurrentIter,
         X: Xap<I = I::Item, O = T>,

src/collectables/inf/fixed_vec.rs

@@ -6,25 +6,29 @@ use orx_concurrent_iter::ConcurrentIter;
 use orx_fixed_vec::FixedVec;
 
 impl<T> ColIntoInf<T> for FixedVec<T> {
-    fn inf_col_into<I, X, R>(dst: Option<Self>, par: ParIter<I, X, R>) -> Self
+    fn new_empty() -> Self {
+        Self::new(0)
+    }
+
+    fn inf_col_into<I, X, R>(dst: &mut Self, par: ParIter<I, X, R>)
     where
         I: ConcurrentIter,
         X: Xap<I = I::Item, O = T>,
         R: ParRunner,
         T: Send,
     {
-        let dst = dst.map(|x| x.into_inner());
-        <Vec<T> as ColIntoInf<T>>::inf_col_into(dst, par).into()
+        let dst = dst.as_mut_vec();
+        <Vec<T> as ColIntoInf<T>>::inf_col_into(dst, par);
     }
 
-    fn inf_arb_col_into<I, X, R>(dst: Option<Self>, par: ParIter<I, X, R>) -> Self
+    fn inf_arb_col_into<I, X, R>(dst: &mut Self, par: ParIter<I, X, R>)
     where
         I: ConcurrentIter,
         X: Xap<I = I::Item, O = T>,
         R: ParRunner,
         T: Send,
     {
-        let dst = dst.map(|x| x.into_inner());
-        <Vec<T> as ColIntoInf<T>>::inf_arb_col_into(dst, par).into()
+        let dst = dst.as_mut_vec();
+        <Vec<T> as ColIntoInf<T>>::inf_arb_col_into(dst, par);
     }
 }

src/collectables/inf/split_vec_doubling.rs

@@ -9,7 +9,11 @@ use orx_concurrent_iter::ConcurrentIter;
 use orx_split_vec::{Doubling, SplitVec};
 
 impl<T> ColIntoInf<T> for SplitVec<T, Doubling> {
-    fn inf_col_into<I, X, R>(dst: Option<Self>, par: ParIter<I, X, R>) -> Self
+    fn new_empty() -> Self {
+        Self::with_doubling_growth()
+    }
+
+    fn inf_col_into<I, X, R>(dst: &mut Self, par: ParIter<I, X, R>)
     where
         I: ConcurrentIter,
         X: Xap<I = I::Item, O = T>,
@@ -18,10 +22,10 @@ impl<T> ColIntoInf<T> for SplitVec<T, Doubling> {
     {
         let (iter, x, mut exe, params) = par.destruct();
         let results = exe.collect(params, iter, x);
-        merge_ord_into_split_vec(results, dst)
+        merge_ord_into_split_vec(results, dst);
     }
 
-    fn inf_arb_col_into<I, X, R>(dst: Option<Self>, par: ParIter<I, X, R>) -> Self
+    fn inf_arb_col_into<I, X, R>(dst: &mut Self, par: ParIter<I, X, R>)
     where
         I: ConcurrentIter,
         X: Xap<I = I::Item, O = T>,
@@ -30,6 +34,6 @@ impl<T> ColIntoInf<T> for SplitVec<T, Doubling> {
     {
         let (iter, x, mut exe, params) = par.destruct();
         let results = exe.collect_arb(params, iter, x);
-        merge_arb_into_split_vec(results, dst.unwrap_or_else(|| Self::with_doubling_growth()))
+        merge_arb_into_split_vec(results, dst);
     }
 }

src/collectables/inf/split_vec_linear.rs

@@ -3,13 +3,17 @@ use crate::collectables::alg::merge_collected::{
 };
 use crate::collectables::inf::ColIntoInf;
 use crate::infallible::ParRunnerInfallible;
-use crate::infallible::{ParIter, ParCore, Xap};
+use crate::infallible::{ParCore, ParIter, Xap};
 use crate::runner::ParRunner;
 use orx_concurrent_iter::ConcurrentIter;
 use orx_split_vec::{Linear, SplitVec};
 
 impl<T> ColIntoInf<T> for SplitVec<T, Linear> {
-    fn inf_col_into<I, X, R>(dst: Option<Self>, par: ParIter<I, X, R>) -> Self
+    fn new_empty() -> Self {
+        Self::with_linear_growth(10)
+    }
+
+    fn inf_col_into<I, X, R>(dst: &mut Self, par: ParIter<I, X, R>)
     where
         I: ConcurrentIter,
         X: Xap<I = I::Item, O = T>,
@@ -18,10 +22,10 @@ impl<T> ColIntoInf<T> for SplitVec<T, Linear> {
     {
         let (iter, x, mut exe, params) = par.destruct();
         let results = exe.collect(params, iter, x);
-        merge_ord_into_split_vec(results, dst)
+        merge_ord_into_split_vec(results, dst);
     }
 
-    fn inf_arb_col_into<I, X, R>(dst: Option<Self>, par: ParIter<I, X, R>) -> Self
+    fn inf_arb_col_into<I, X, R>(dst: &mut Self, par: ParIter<I, X, R>)
     where
         I: ConcurrentIter,
         X: Xap<I = I::Item, O = T>,
@@ -30,6 +34,6 @@ impl<T> ColIntoInf<T> for SplitVec<T, Linear> {
     {
         let (iter, x, mut exe, params) = par.destruct();
         let results = exe.collect_arb(params, iter, x);
-        merge_arb_into_split_vec(results, dst.unwrap_or_else(|| Self::with_linear_growth(10)))
+        merge_arb_into_split_vec(results, dst);
     }
 }

src/collectables/inf/split_vec_recursive.rs

@@ -1,13 +1,19 @@
-use crate::collectables::alg::merge_collected::merge_ord_into_split_vec;
+use crate::collectables::alg::merge_collected::{
+    merge_arb_into_split_vec, merge_ord_into_split_vec,
+};
 use crate::collectables::inf::ColIntoInf;
 use crate::infallible::ParRunnerInfallible;
-use crate::infallible::{ParIter, ParCore, Xap};
+use crate::infallible::{ParCore, ParIter, Xap};
 use crate::runner::ParRunner;
 use orx_concurrent_iter::ConcurrentIter;
 use orx_split_vec::{Recursive, SplitVec};
 
 impl<T> ColIntoInf<T> for SplitVec<T, Recursive> {
-    fn inf_col_into<I, X, R>(dst: Option<Self>, par: ParIter<I, X, R>) -> Self
+    fn new_empty() -> Self {
+        Self::with_recursive_growth()
+    }
+
+    fn inf_col_into<I, X, R>(dst: &mut Self, par: ParIter<I, X, R>)
     where
         I: ConcurrentIter,
         X: Xap<I = I::Item, O = T>,
@@ -16,10 +22,10 @@ impl<T> ColIntoInf<T> for SplitVec<T, Recursive> {
     {
         let (iter, x, mut exe, params) = par.destruct();
         let results = exe.collect(params, iter, x);
-        merge_ord_into_split_vec(results, dst)
+        merge_ord_into_split_vec(results, dst);
     }
 
-    fn inf_arb_col_into<I, X, R>(dst: Option<Self>, par: ParIter<I, X, R>) -> Self
+    fn inf_arb_col_into<I, X, R>(dst: &mut Self, par: ParIter<I, X, R>)
     where
         I: ConcurrentIter,
         X: Xap<I = I::Item, O = T>,
@@ -28,10 +34,6 @@ impl<T> ColIntoInf<T> for SplitVec<T, Recursive> {
     {
         let (iter, x, mut exe, params) = par.destruct();
         let results = exe.collect_arb(params, iter, x);
-        let mut dst = dst.unwrap_or_else(|| Self::with_recursive_growth());
-        for vec in results {
-            dst.append(vec);
-        }
-        dst
+        merge_arb_into_split_vec(results, dst);
     }
 }

src/collectables/inf/vec.rs

@@ -1,6 +1,4 @@
-use crate::collectables::alg::merge_collected::{
-    merge_arb_into_first_vec, merge_arb_into_vec, merge_ord_into_vec,
-};
+use crate::collectables::alg::merge_collected::{merge_arb_into_vec, merge_ord_into_vec};
 use crate::collectables::inf::ColIntoInf;
 use crate::infallible::ParRunnerInfallible;
 use crate::infallible::{ParCore, ParIter, Xap};
@@ -9,7 +7,11 @@ use alloc::vec::Vec;
 use orx_concurrent_iter::ConcurrentIter;
 
 impl<T> ColIntoInf<T> for Vec<T> {
-    fn inf_col_into<I, X, R>(dst: Option<Self>, par: ParIter<I, X, R>) -> Self
+    fn new_empty() -> Self {
+        Self::new()
+    }
+
+    fn inf_col_into<I, X, R>(dst: &mut Self, par: ParIter<I, X, R>)
     where
         I: ConcurrentIter,
         X: Xap<I = I::Item, O = T>,
@@ -18,10 +20,10 @@ impl<T> ColIntoInf<T> for Vec<T> {
     {
         let (iter, x, mut exe, params) = par.destruct();
         let results = exe.collect(params, iter, x);
-        merge_ord_into_vec(results, dst)
+        merge_ord_into_vec(results, dst);
     }
 
-    fn inf_arb_col_into<I, X, R>(dst: Option<Self>, par: ParIter<I, X, R>) -> Self
+    fn inf_arb_col_into<I, X, R>(dst: &mut Self, par: ParIter<I, X, R>)
     where
         I: ConcurrentIter,
         X: Xap<I = I::Item, O = T>,
@@ -30,10 +32,6 @@ impl<T> ColIntoInf<T> for Vec<T> {
     {
         let (iter, x, mut exe, params) = par.destruct();
         let results = exe.collect_arb(params, iter, x);
-
-        match dst {
-            Some(dst) => merge_arb_into_vec(results, dst),
-            None => merge_arb_into_first_vec(results),
-        }
+        merge_arb_into_vec(results, dst);
     }
 }