Implement ParallelExtend for tuples

[semtexzv]

I am currently working on a project , that needs to recursively split the input data to several categories.
Using ParallelIterator::partition_map i can split the input data into 2, but this is not recursive,
If for example I return Either<Either<A,B>,C> from my iterator, I am unable to partition the data into
((Vec<A>,Vec<B>),Vec<C>).

So far I have been unable to implement this on my own, and would appreciate help.

My idea was to implement this trait for tuples, something like this

impl<R, S, T> ParallelExtend<T> for (R, S)
    where R: ParallelExtend<T>,
               S: ParallelExtend<T>
    {
        fn par_extend<I>(&mut self, par_iter: I) where I: IntoParallelIterator<Item=Either<R, S>> {
    }
}

I need this functionality to partition the input data into several containers with heterogenous types, and do it as fast as possible.

[cuviper]

I think the signature you need is actually like this:

impl<L, R, T, U> ParallelExtend<Either<L, R>> for (T, U)
where
    L: Send,
    R: Send,
    T: ParallelExtend<L>,
    U: ParallelExtend<R>,
{
    fn par_extend<I>(&mut self, par_iter: I)
    where
        I: IntoParallelIterator<Item = Either<L, R>>,
    {
        unimplemented!()
    }
}

My first thought when reading the subject of this issue was that it would be more like unzip:

impl<A, B, T, U> ParallelExtend<(A, B)> for (T, U)
where
    A: Send,
    B: Send,
    T: ParallelExtend<A>,
    U: ParallelExtend<B>,
{
    fn par_extend<I>(&mut self, par_iter: I)
    where
        I: IntoParallelIterator<Item = (A, B)>,
    {
        unimplemented!()
    }
}

It looks like rustc is happy to let these co-exist!