pub struct InnerJoin<P, K, V1, V2> { /* private fields */ }Implementations§
Trait Implementations§
Source§impl<P, K, V1, V2, Input> DistributedPipe<Input> for InnerJoin<P, K, V1, V2>
impl<P, K, V1, V2, Input> DistributedPipe<Input> for InnerJoin<P, K, V1, V2>
type Output = (K, ImplIter<V1>, ImplIter<V2>)
type Task = <FilterMapSync<P, InnerJoinClosure<K, V1, V2>> as DistributedPipe<Input>>::Task
fn task(&self) -> Self::Task
fn inspect<F>(self, f: F) -> Inspect<Self, F>
fn update<F>(self, f: F) -> Update<Self, F>
fn map<B, F>(self, f: F) -> Map<Self, F>
fn flat_map<B, F>(self, f: F) -> FlatMap<Self, F>
fn filter<F>(self, f: F) -> Filter<Self, F>
fn cloned<'a, T>(self) -> Cloned<Self, T, Input>
fn left_join<K, V1, V2>(
self,
right: impl IntoIterator<Item = (K, V2)>,
) -> LeftJoin<Self, K, V1, V2>where
K: Eq + Hash + Clone + ProcessSend + 'static,
V1: 'static,
V2: Clone + ProcessSend + 'static,
Self: DistributedPipe<Input, Output = (K, V1)> + Sized,
fn inner_join<K, V1, V2>(
self,
right: impl IntoIterator<Item = (K, V2)>,
) -> InnerJoin<Self, K, V1, V2>where
K: Eq + Hash + Clone + ProcessSend + 'static,
V1: 'static,
V2: Clone + ProcessSend + 'static,
Self: DistributedPipe<Input, Output = (K, V1)> + Sized,
fn pipe<S>(self, sink: S) -> Pipe<Self, S>
fn fork<A, B, RefAItem>( self, sink: A, sink_ref: B, ) -> Fork<Self, A, B, &'static Self::Output>
fn for_each<F>(self, f: F) -> ForEach<Self, F>
fn fold<ID, F, B>(self, identity: ID, op: F) -> Fold<Self, ID, F, B>where
ID: FnMut() -> B + Clone + ProcessSend + 'static,
F: FnMut(B, Either<Self::Output, B>) -> B + Clone + ProcessSend + 'static,
B: ProcessSend + 'static,
Self: Sized,
fn group_by<S, A, B>(self, sink: S) -> GroupBy<Self, S>where
A: Eq + Hash + ProcessSend + 'static,
S: DistributedSink<B>,
<S::Pipe as DistributedPipe<B>>::Task: Clone + ProcessSend + 'static,
S::ReduceA: 'static,
S::ReduceC: Clone,
S::Done: ProcessSend + 'static,
Self: DistributedPipe<Input, Output = (A, B)> + Sized,
fn histogram(self) -> Histogram<Self>
fn sort_n_by<F>(self, n: usize, cmp: F) -> Sort<Self, F>where
F: Fn(&Self::Output, &Self::Output) -> Ordering + Clone + ProcessSend + 'static,
Self::Output: Clone + ProcessSend + 'static,
Self: Sized,
fn count(self) -> Count<Self>where
Self: Sized,
fn sum<B>(self) -> Sum<Self, B>
fn mean(self) -> Mean<Self>
fn stddev(self) -> StdDev<Self>
fn combine<F>(self, f: F) -> Combine<Self, F>where
F: FnMut(Self::Output, Self::Output) -> Self::Output + Clone + ProcessSend + 'static,
Self::Output: ProcessSend + 'static,
Self: Sized,
fn max(self) -> Max<Self>
fn max_by<F>(self, f: F) -> MaxBy<Self, F>where
F: FnMut(&Self::Output, &Self::Output) -> Ordering + Clone + ProcessSend + 'static,
Self::Output: ProcessSend + 'static,
Self: Sized,
fn max_by_key<F, B>(self, f: F) -> MaxByKey<Self, F>where
F: FnMut(&Self::Output) -> B + Clone + ProcessSend + 'static,
B: Ord + 'static,
Self::Output: ProcessSend + 'static,
Self: Sized,
fn min(self) -> Min<Self>
fn min_by<F>(self, f: F) -> MinBy<Self, F>where
F: FnMut(&Self::Output, &Self::Output) -> Ordering + Clone + ProcessSend + 'static,
Self::Output: ProcessSend + 'static,
Self: Sized,
fn min_by_key<F, B>(self, f: F) -> MinByKey<Self, F>where
F: FnMut(&Self::Output) -> B + Clone + ProcessSend + 'static,
B: Ord + 'static,
Self::Output: ProcessSend + 'static,
Self: Sized,
fn most_frequent( self, n: usize, probability: f64, tolerance: f64, ) -> MostFrequent<Self>
fn most_distinct<A, B>(
self,
n: usize,
probability: f64,
tolerance: f64,
error_rate: f64,
) -> MostDistinct<Self>where
Self: DistributedPipe<Input, Output = (A, B)> + Sized,
A: Hash + Eq + Clone + ProcessSend + 'static,
B: Hash + 'static,
fn sample_unstable(self, samples: usize) -> SampleUnstable<Self>
fn all<F>(self, f: F) -> All<Self, F>
fn any<F>(self, f: F) -> Any<Self, F>
fn collect<B>(self) -> Collect<Self, B>
Source§impl<P, K, V1, V2> DistributedStream for InnerJoin<P, K, V1, V2>
impl<P, K, V1, V2> DistributedStream for InnerJoin<P, K, V1, V2>
type Item = (K, ImplIter<V1>, ImplIter<V2>)
type Task = <FilterMapSync<P, InnerJoinClosure<K, V1, V2>> as DistributedStream>::Task
fn size_hint(&self) -> (usize, Option<usize>)
fn next_task( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Option<Self::Task>>
fn reduce<'life0, 'async_trait, P, B, R1, R2, R3>(
self,
pool: &'life0 P,
reduce_a: R1,
reduce_b: R2,
reduce_c: R3,
) -> Pin<Box<dyn Future<Output = B> + 'async_trait>>where
P: ProcessPool + 'async_trait,
R1: ReducerSend<Self::Item> + Clone + ProcessSend + 'static + 'async_trait,
R2: ReducerProcessSend<<R1 as ReducerSend<Self::Item>>::Done> + Clone + ProcessSend + 'static + 'async_trait,
R3: Reducer<<R2 as ReducerProcessSend<<R1 as ReducerSend<Self::Item>>::Done>>::Done, Done = B> + 'async_trait,
Self::Task: 'static,
Self: Sized + 'async_trait,
B: 'async_trait,
'life0: 'async_trait,
fn pipe<'life0, 'async_trait, P, DistSink, A>(
self,
pool: &'life0 P,
sink: DistSink,
) -> Pin<Box<dyn Future<Output = A> + 'async_trait>>where
P: ProcessPool + 'async_trait,
DistSink: DistributedSink<Self::Item, Done = A> + 'async_trait,
<DistSink::Pipe as DistributedPipe<Self::Item>>::Task: 'static,
DistSink::ReduceA: 'static,
DistSink::ReduceB: 'static,
Self::Task: 'static,
Self: Sized + 'async_trait,
A: 'async_trait,
'life0: 'async_trait,
fn fork<'life0, 'async_trait, P, DistSinkA, DistSinkB, A, B>(
self,
pool: &'life0 P,
sink_a: DistSinkA,
sink_b: DistSinkB,
) -> Pin<Box<dyn Future<Output = (A, B)> + 'async_trait>>where
P: ProcessPool + 'async_trait,
DistSinkA: DistributedSink<Self::Item, Done = A> + 'async_trait,
DistSinkB: for<'a> DistributedSink<&'a Self::Item, Done = B> + 'static + 'async_trait,
<DistSinkA::Pipe as DistributedPipe<Self::Item>>::Task: 'static,
DistSinkA::ReduceA: 'static,
DistSinkA::ReduceB: 'static,
<DistSinkB as DistributedSink<&'static Self::Item>>::ReduceA: 'static,
<DistSinkB as DistributedSink<&'static Self::Item>>::ReduceB: 'static,
<<DistSinkB as DistributedSink<&'static Self::Item>>::Pipe as DistributedPipe<&'static Self::Item>>::Task: 'static,
Self::Item: 'static,
Self::Task: 'static,
Self: Sized + 'async_trait,
A: 'async_trait,
B: 'async_trait,
'life0: 'async_trait,
fn group_by<'life0, 'async_trait, P, S, A, B>(
self,
pool: &'life0 P,
sink: S,
) -> Pin<Box<dyn Future<Output = IndexMap<A, S::Done>> + 'async_trait>>where
P: ProcessPool + 'async_trait,
A: Eq + Hash + ProcessSend + 'static + 'async_trait,
B: 'static + 'async_trait,
S: DistributedSink<B> + 'async_trait,
<S::Pipe as DistributedPipe<B>>::Task: Clone + ProcessSend + 'static,
S::ReduceA: 'static,
S::ReduceB: 'static,
S::ReduceC: Clone,
S::Done: ProcessSend + 'static,
Self::Task: 'static,
Self: DistributedStream<Item = (A, B)> + Sized + 'async_trait,
'life0: 'async_trait,
fn collect<'life0, 'async_trait, P, B>(
self,
pool: &'life0 P,
) -> Pin<Box<dyn Future<Output = B> + 'async_trait>>where
P: ProcessPool + 'async_trait,
B: FromDistributedStream<Self::Item> + 'async_trait,
B::ReduceA: ProcessSend + 'static,
B::ReduceB: ProcessSend + 'static,
Self::Task: 'static,
Self: Sized + 'async_trait,
'life0: 'async_trait,
fn inspect<F>(self, f: F) -> Inspect<Self, F>
fn update<F>(self, f: F) -> Update<Self, F>
fn map<B, F>(self, f: F) -> Map<Self, F>
fn flat_map<B, F>(self, f: F) -> FlatMap<Self, F>
fn filter<F>(self, f: F) -> Filter<Self, F>
fn left_join<K, V1, V2>(
self,
right: impl IntoIterator<Item = (K, V2)>,
) -> LeftJoin<Self, K, V1, V2>where
K: Eq + Hash + Clone + ProcessSend + 'static,
V1: 'static,
V2: Clone + ProcessSend + 'static,
Self: DistributedStream<Item = (K, V1)> + Sized,
fn inner_join<K, V1, V2>(
self,
right: impl IntoIterator<Item = (K, V2)>,
) -> InnerJoin<Self, K, V1, V2>where
K: Eq + Hash + Clone + ProcessSend + 'static,
V1: 'static,
V2: Clone + ProcessSend + 'static,
Self: DistributedStream<Item = (K, V1)> + Sized,
fn chain<C>(self, chain: C) -> Chain<Self, C::DistStream>
fn for_each<'life0, 'async_trait, P, F>(
self,
pool: &'life0 P,
f: F,
) -> Pin<Box<dyn Future<Output = ()> + 'async_trait>>where
P: ProcessPool + 'async_trait,
F: FnMut(Self::Item) + Clone + ProcessSend + 'static + 'async_trait,
Self::Item: 'static,
Self::Task: 'static,
Self: Sized + 'async_trait,
'life0: 'async_trait,
fn fold<'life0, 'async_trait, P, ID, F, B>(
self,
pool: &'life0 P,
identity: ID,
op: F,
) -> Pin<Box<dyn Future<Output = B> + 'async_trait>>where
P: ProcessPool + 'async_trait,
ID: FnMut() -> B + Clone + ProcessSend + 'static + 'async_trait,
F: FnMut(B, Either<Self::Item, B>) -> B + Clone + ProcessSend + 'static + 'async_trait,
B: ProcessSend + 'static + 'async_trait,
Self::Item: 'static,
Self::Task: 'static,
Self: Sized + 'async_trait,
'life0: 'async_trait,
fn histogram<'life0, 'async_trait, P>(
self,
pool: &'life0 P,
) -> Pin<Box<dyn Future<Output = Vec<(Self::Item, usize)>> + 'async_trait>>where
P: ProcessPool + 'async_trait,
Self::Item: Hash + Ord + ProcessSend + 'static,
Self::Task: 'static,
Self: Sized + 'async_trait,
'life0: 'async_trait,
fn sort_n_by<'life0, 'async_trait, P, F>(
self,
pool: &'life0 P,
n: usize,
cmp: F,
) -> Pin<Box<dyn Future<Output = Sort<Self::Item, F>> + 'async_trait>>where
P: ProcessPool + 'async_trait,
F: Fn(&Self::Item, &Self::Item) -> Ordering + Clone + ProcessSend + 'static + 'async_trait,
Self::Item: Clone + ProcessSend + 'static,
Self::Task: 'static,
Self: Sized + 'async_trait,
'life0: 'async_trait,
fn count<'life0, 'async_trait, P>(
self,
pool: &'life0 P,
) -> Pin<Box<dyn Future<Output = usize> + 'async_trait>>where
P: ProcessPool + 'async_trait,
Self::Item: 'static,
Self::Task: 'static,
Self: Sized + 'async_trait,
'life0: 'async_trait,
fn sum<'life0, 'async_trait, P, S>(
self,
pool: &'life0 P,
) -> Pin<Box<dyn Future<Output = S> + 'async_trait>>where
P: ProcessPool + 'async_trait,
S: Sum<Self::Item> + Sum<S> + ProcessSend + 'static + 'async_trait,
Self::Item: 'static,
Self::Task: 'static,
Self: Sized + 'async_trait,
'life0: 'async_trait,
fn combine<'life0, 'async_trait, P, F>(
self,
pool: &'life0 P,
f: F,
) -> Pin<Box<dyn Future<Output = Option<Self::Item>> + 'async_trait>>where
P: ProcessPool + 'async_trait,
F: FnMut(Self::Item, Self::Item) -> Self::Item + Clone + ProcessSend + 'static + 'async_trait,
Self::Item: ProcessSend + 'static,
Self::Task: 'static,
Self: Sized + 'async_trait,
'life0: 'async_trait,
fn max<'life0, 'async_trait, P>(
self,
pool: &'life0 P,
) -> Pin<Box<dyn Future<Output = Option<Self::Item>> + 'async_trait>>where
P: ProcessPool + 'async_trait,
Self::Item: Ord + ProcessSend + 'static,
Self::Task: 'static,
Self: Sized + 'async_trait,
'life0: 'async_trait,
fn max_by<'life0, 'async_trait, P, F>(
self,
pool: &'life0 P,
f: F,
) -> Pin<Box<dyn Future<Output = Option<Self::Item>> + 'async_trait>>where
P: ProcessPool + 'async_trait,
F: FnMut(&Self::Item, &Self::Item) -> Ordering + Clone + ProcessSend + 'static + 'async_trait,
Self::Item: ProcessSend + 'static,
Self::Task: 'static,
Self: Sized + 'async_trait,
'life0: 'async_trait,
fn max_by_key<'life0, 'async_trait, P, F, B>(
self,
pool: &'life0 P,
f: F,
) -> Pin<Box<dyn Future<Output = Option<Self::Item>> + 'async_trait>>where
P: ProcessPool + 'async_trait,
F: FnMut(&Self::Item) -> B + Clone + ProcessSend + 'static + 'async_trait,
B: Ord + 'static + 'async_trait,
Self::Item: ProcessSend + 'static,
Self::Task: 'static,
Self: Sized + 'async_trait,
'life0: 'async_trait,
fn min<'life0, 'async_trait, P>(
self,
pool: &'life0 P,
) -> Pin<Box<dyn Future<Output = Option<Self::Item>> + 'async_trait>>where
P: ProcessPool + 'async_trait,
Self::Item: Ord + ProcessSend + 'static,
Self::Task: 'static,
Self: Sized + 'async_trait,
'life0: 'async_trait,
fn min_by<'life0, 'async_trait, P, F>(
self,
pool: &'life0 P,
f: F,
) -> Pin<Box<dyn Future<Output = Option<Self::Item>> + 'async_trait>>where
P: ProcessPool + 'async_trait,
F: FnMut(&Self::Item, &Self::Item) -> Ordering + Clone + ProcessSend + 'static + 'async_trait,
Self::Item: ProcessSend + 'static,
Self::Task: 'static,
Self: Sized + 'async_trait,
'life0: 'async_trait,
fn min_by_key<'life0, 'async_trait, P, F, B>(
self,
pool: &'life0 P,
f: F,
) -> Pin<Box<dyn Future<Output = Option<Self::Item>> + 'async_trait>>where
P: ProcessPool + 'async_trait,
F: FnMut(&Self::Item) -> B + Clone + ProcessSend + 'static + 'async_trait,
B: Ord + 'static + 'async_trait,
Self::Item: ProcessSend + 'static,
Self::Task: 'static,
Self: Sized + 'async_trait,
'life0: 'async_trait,
fn most_frequent<'life0, 'async_trait, P>(
self,
pool: &'life0 P,
n: usize,
probability: f64,
tolerance: f64,
) -> Pin<Box<dyn Future<Output = Top<Self::Item, usize>> + 'async_trait>>where
P: ProcessPool + 'async_trait,
Self::Item: Hash + Eq + Clone + ProcessSend + 'static,
Self::Task: 'static,
Self: Sized + 'async_trait,
'life0: 'async_trait,
fn most_distinct<'life0, 'async_trait, P, A, B>(
self,
pool: &'life0 P,
n: usize,
probability: f64,
tolerance: f64,
error_rate: f64,
) -> Pin<Box<dyn Future<Output = Top<A, HyperLogLogMagnitude<B>>> + 'async_trait>>where
P: ProcessPool + 'async_trait,
Self: DistributedStream<Item = (A, B)> + Sized + 'async_trait,
A: Hash + Eq + Clone + ProcessSend + 'static + 'async_trait,
B: Hash + 'static + 'async_trait,
Self::Task: 'static,
'life0: 'async_trait,
fn sample_unstable<'life0, 'async_trait, P>(
self,
pool: &'life0 P,
samples: usize,
) -> Pin<Box<dyn Future<Output = SampleUnstable<Self::Item>> + 'async_trait>>where
P: ProcessPool + 'async_trait,
Self::Item: ProcessSend + 'static,
Self::Task: 'static,
Self: Sized + 'async_trait,
'life0: 'async_trait,
fn all<'life0, 'async_trait, P, F>(
self,
pool: &'life0 P,
f: F,
) -> Pin<Box<dyn Future<Output = bool> + 'async_trait>>where
P: ProcessPool + 'async_trait,
F: FnMut(Self::Item) -> bool + Clone + ProcessSend + 'static + 'async_trait,
Self::Item: 'static,
Self::Task: 'static,
Self: Sized + 'async_trait,
'life0: 'async_trait,
fn any<'life0, 'async_trait, P, F>(
self,
pool: &'life0 P,
f: F,
) -> Pin<Box<dyn Future<Output = bool> + 'async_trait>>where
P: ProcessPool + 'async_trait,
F: FnMut(Self::Item) -> bool + Clone + ProcessSend + 'static + 'async_trait,
Self::Item: 'static,
Self::Task: 'static,
Self: Sized + 'async_trait,
'life0: 'async_trait,
Source§impl<P, K, V1, V2, Input> ParallelPipe<Input> for InnerJoin<P, K, V1, V2>
impl<P, K, V1, V2, Input> ParallelPipe<Input> for InnerJoin<P, K, V1, V2>
type Output = (K, ImplIter<V1>, ImplIter<V2>)
type Task = <FilterMapSync<P, InnerJoinClosure<K, V1, V2>> as ParallelPipe<Input>>::Task
fn task(&self) -> Self::Task
fn inspect<F>(self, f: F) -> Inspect<Self, F>
fn update<F>(self, f: F) -> Update<Self, F>
fn map<B, F>(self, f: F) -> Map<Self, F>
fn flat_map<B, F>(self, f: F) -> FlatMap<Self, F>
fn filter<F>(self, f: F) -> Filter<Self, F>
fn cloned<'a, T>(self) -> Cloned<Self, T, Input>
fn left_join<K, V1, V2>( self, right: impl IntoIterator<Item = (K, V2)>, ) -> LeftJoin<Self, K, V1, V2>
fn inner_join<K, V1, V2>( self, right: impl IntoIterator<Item = (K, V2)>, ) -> InnerJoin<Self, K, V1, V2>
fn pipe<S>(self, sink: S) -> Pipe<Self, S>
fn fork<A, B, RefAItem>( self, sink: A, sink_ref: B, ) -> Fork<Self, A, B, &'static Self::Output>
fn for_each<F>(self, f: F) -> ForEach<Self, F>
fn fold<ID, F, B>(self, identity: ID, op: F) -> Fold<Self, ID, F, B>
fn group_by<S, A, B>(self, sink: S) -> GroupBy<Self, S>
fn histogram(self) -> Histogram<Self>
fn sort_n_by<F>(self, n: usize, cmp: F) -> Sort<Self, F>
fn count(self) -> Count<Self>where
Self: Sized,
fn sum<B>(self) -> Sum<Self, B>
fn mean(self) -> Mean<Self>
fn stddev(self) -> StdDev<Self>
fn combine<F>(self, f: F) -> Combine<Self, F>
fn max(self) -> Max<Self>
fn max_by<F>(self, f: F) -> MaxBy<Self, F>
fn max_by_key<F, B>(self, f: F) -> MaxByKey<Self, F>
fn min(self) -> Min<Self>
fn min_by<F>(self, f: F) -> MinBy<Self, F>
fn min_by_key<F, B>(self, f: F) -> MinByKey<Self, F>
fn most_frequent( self, n: usize, probability: f64, tolerance: f64, ) -> MostFrequent<Self>
fn most_distinct<A, B>( self, n: usize, probability: f64, tolerance: f64, error_rate: f64, ) -> MostDistinct<Self>
fn sample_unstable(self, samples: usize) -> SampleUnstable<Self>
fn all<F>(self, f: F) -> All<Self, F>
fn any<F>(self, f: F) -> Any<Self, F>
fn collect<B>(self) -> Collect<Self, B>
Source§impl<P, K, V1, V2> ParallelStream for InnerJoin<P, K, V1, V2>
impl<P, K, V1, V2> ParallelStream for InnerJoin<P, K, V1, V2>
type Item = (K, ImplIter<V1>, ImplIter<V2>)
type Task = <FilterMapSync<P, InnerJoinClosure<K, V1, V2>> as ParallelStream>::Task
fn size_hint(&self) -> (usize, Option<usize>)
fn next_task( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Option<Self::Task>>
fn reduce<'life0, 'async_trait, P, B, R1, R3>(
self,
pool: &'life0 P,
reduce_a: R1,
reduce_c: R3,
) -> Pin<Box<dyn Future<Output = B> + 'async_trait>>where
P: ThreadPool + 'async_trait,
R1: ReducerSend<Self::Item> + Clone + Send + 'static + 'async_trait,
R3: Reducer<<R1 as ReducerSend<Self::Item>>::Done, Done = B> + 'async_trait,
Self::Task: 'static,
Self: Sized + 'async_trait,
B: 'async_trait,
'life0: 'async_trait,
fn pipe<'life0, 'async_trait, P, ParSink, A>(
self,
pool: &'life0 P,
sink: ParSink,
) -> Pin<Box<dyn Future<Output = A> + 'async_trait>>where
P: ThreadPool + 'async_trait,
ParSink: ParallelSink<Self::Item, Done = A> + 'async_trait,
<ParSink::Pipe as ParallelPipe<Self::Item>>::Task: 'static,
ParSink::ReduceA: 'static,
Self::Task: 'static,
Self: Sized + 'async_trait,
A: 'async_trait,
'life0: 'async_trait,
fn fork<'life0, 'async_trait, P, ParSinkA, ParSinkB, A, B>(
self,
pool: &'life0 P,
sink_a: ParSinkA,
sink_b: ParSinkB,
) -> Pin<Box<dyn Future<Output = (A, B)> + 'async_trait>>where
P: ThreadPool + 'async_trait,
ParSinkA: ParallelSink<Self::Item, Done = A> + 'async_trait,
ParSinkB: for<'a> ParallelSink<&'a Self::Item, Done = B> + 'static + 'async_trait,
<ParSinkA::Pipe as ParallelPipe<Self::Item>>::Task: 'static,
ParSinkA::ReduceA: 'static,
<ParSinkB as ParallelSink<&'static Self::Item>>::ReduceA: 'static,
<<ParSinkB as ParallelSink<&'static Self::Item>>::Pipe as ParallelPipe<&'static Self::Item>>::Task: 'static,
Self::Item: 'static,
Self::Task: 'static,
Self: Sized + 'async_trait,
A: 'async_trait,
B: 'async_trait,
'life0: 'async_trait,
fn group_by<'life0, 'async_trait, P, S, A, B>(
self,
pool: &'life0 P,
sink: S,
) -> Pin<Box<dyn Future<Output = IndexMap<A, S::Done>> + 'async_trait>>where
P: ThreadPool + 'async_trait,
A: Eq + Hash + Send + 'static + 'async_trait,
B: 'static + 'async_trait,
S: ParallelSink<B> + 'async_trait,
<S::Pipe as ParallelPipe<B>>::Task: Clone + Send + 'static,
S::ReduceA: 'static,
S::ReduceC: Clone,
S::Done: Send + 'static,
Self::Task: 'static,
Self: ParallelStream<Item = (A, B)> + Sized + 'async_trait,
'life0: 'async_trait,
fn collect<'life0, 'async_trait, P, B>(
self,
pool: &'life0 P,
) -> Pin<Box<dyn Future<Output = B> + 'async_trait>>where
P: ThreadPool + 'async_trait,
B: FromParallelStream<Self::Item> + 'async_trait,
B::ReduceA: Send + 'static,
Self::Task: 'static,
Self: Sized + 'async_trait,
'life0: 'async_trait,
fn inspect<F>(self, f: F) -> Inspect<Self, F>
fn update<F>(self, f: F) -> Update<Self, F>
fn map<B, F>(self, f: F) -> Map<Self, F>
fn flat_map<B, F>(self, f: F) -> FlatMap<Self, F>
fn filter<F>(self, f: F) -> Filter<Self, F>
fn left_join<K, V1, V2>( self, right: impl IntoIterator<Item = (K, V2)>, ) -> LeftJoin<Self, K, V1, V2>
fn inner_join<K, V1, V2>( self, right: impl IntoIterator<Item = (K, V2)>, ) -> InnerJoin<Self, K, V1, V2>
fn chain<C>(self, chain: C) -> Chain<Self, C::ParStream>
fn for_each<'life0, 'async_trait, P, F>( self, pool: &'life0 P, f: F, ) -> Pin<Box<dyn Future<Output = ()> + 'async_trait>>
fn fold<'life0, 'async_trait, P, ID, F, B>(
self,
pool: &'life0 P,
identity: ID,
op: F,
) -> Pin<Box<dyn Future<Output = B> + 'async_trait>>where
P: ThreadPool + 'async_trait,
ID: FnMut() -> B + Clone + Send + 'static + 'async_trait,
F: FnMut(B, Either<Self::Item, B>) -> B + Clone + Send + 'static + 'async_trait,
B: Send + 'static + 'async_trait,
Self::Item: 'static,
Self::Task: 'static,
Self: Sized + 'async_trait,
'life0: 'async_trait,
fn histogram<'life0, 'async_trait, P>( self, pool: &'life0 P, ) -> Pin<Box<dyn Future<Output = Vec<(Self::Item, usize)>> + 'async_trait>>
fn sort_n_by<'life0, 'async_trait, P, F>( self, pool: &'life0 P, n: usize, cmp: F, ) -> Pin<Box<dyn Future<Output = Sort<Self::Item, F>> + 'async_trait>>
fn count<'life0, 'async_trait, P>(
self,
pool: &'life0 P,
) -> Pin<Box<dyn Future<Output = usize> + 'async_trait>>where
P: ThreadPool + 'async_trait,
Self::Item: 'static,
Self::Task: 'static,
Self: Sized + 'async_trait,
'life0: 'async_trait,
fn sum<'life0, 'async_trait, P, S>( self, pool: &'life0 P, ) -> Pin<Box<dyn Future<Output = S> + 'async_trait>>
fn combine<'life0, 'async_trait, P, F>( self, pool: &'life0 P, f: F, ) -> Pin<Box<dyn Future<Output = Option<Self::Item>> + 'async_trait>>
fn max<'life0, 'async_trait, P>( self, pool: &'life0 P, ) -> Pin<Box<dyn Future<Output = Option<Self::Item>> + 'async_trait>>
fn max_by<'life0, 'async_trait, P, F>( self, pool: &'life0 P, f: F, ) -> Pin<Box<dyn Future<Output = Option<Self::Item>> + 'async_trait>>
fn max_by_key<'life0, 'async_trait, P, F, B>( self, pool: &'life0 P, f: F, ) -> Pin<Box<dyn Future<Output = Option<Self::Item>> + 'async_trait>>
fn min<'life0, 'async_trait, P>( self, pool: &'life0 P, ) -> Pin<Box<dyn Future<Output = Option<Self::Item>> + 'async_trait>>
fn min_by<'life0, 'async_trait, P, F>( self, pool: &'life0 P, f: F, ) -> Pin<Box<dyn Future<Output = Option<Self::Item>> + 'async_trait>>
fn min_by_key<'life0, 'async_trait, P, F, B>( self, pool: &'life0 P, f: F, ) -> Pin<Box<dyn Future<Output = Option<Self::Item>> + 'async_trait>>
fn most_frequent<'life0, 'async_trait, P>( self, pool: &'life0 P, n: usize, probability: f64, tolerance: f64, ) -> Pin<Box<dyn Future<Output = Top<Self::Item, usize>> + 'async_trait>>
fn most_distinct<'life0, 'async_trait, P, A, B>(
self,
pool: &'life0 P,
n: usize,
probability: f64,
tolerance: f64,
error_rate: f64,
) -> Pin<Box<dyn Future<Output = Top<A, HyperLogLogMagnitude<B>>> + 'async_trait>>where
P: ThreadPool + 'async_trait,
Self: ParallelStream<Item = (A, B)> + Sized + 'async_trait,
A: Hash + Eq + Clone + Send + 'static + 'async_trait,
B: Hash + 'static + 'async_trait,
Self::Task: 'static,
'life0: 'async_trait,
fn sample_unstable<'life0, 'async_trait, P>(
self,
pool: &'life0 P,
samples: usize,
) -> Pin<Box<dyn Future<Output = SampleUnstable<Self::Item>> + 'async_trait>>where
P: ThreadPool + 'async_trait,
Self::Item: Send + 'static,
Self::Task: 'static,
Self: Sized + 'async_trait,
'life0: 'async_trait,
fn all<'life0, 'async_trait, P, F>( self, pool: &'life0 P, f: F, ) -> Pin<Box<dyn Future<Output = bool> + 'async_trait>>
fn any<'life0, 'async_trait, P, F>( self, pool: &'life0 P, f: F, ) -> Pin<Box<dyn Future<Output = bool> + 'async_trait>>
impl<'pin, P, K, V1, V2> Unpin for InnerJoin<P, K, V1, V2>where
__InnerJoin<'pin, P, K, V1, V2>: Unpin,
impl<P, K, V1, V2> UnsafeUnpin for InnerJoin<P, K, V1, V2>
Auto Trait Implementations§
impl<P, K, V1, V2> Freeze for InnerJoin<P, K, V1, V2>where
P: Freeze,
impl<P, K, V1, V2> RefUnwindSafe for InnerJoin<P, K, V1, V2>
impl<P, K, V1, V2> Send for InnerJoin<P, K, V1, V2>
impl<P, K, V1, V2> Sync for InnerJoin<P, K, V1, V2>
impl<P, K, V1, V2> UnwindSafe for InnerJoin<P, K, V1, V2>
Blanket Implementations§
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
Source§impl<T> IntoDistributedStream for Twhere
T: DistributedStream,
impl<T> IntoDistributedStream for Twhere
T: DistributedStream,
type DistStream = T
type Item = <T as DistributedStream>::Item
fn into_dist_stream(self) -> <T as IntoDistributedStream>::DistStream
fn par_stream_mut(&mut self) -> <&mut Self as IntoDistributedStream>::DistStreamwhere
for<'a> &'a mut Self: IntoDistributedStream,
fn dist_stream(&self) -> <&Self as IntoDistributedStream>::DistStreamwhere
for<'a> &'a Self: IntoDistributedStream,
Source§impl<T> IntoEither for T
impl<T> IntoEither for T
Source§fn into_either(self, into_left: bool) -> Either<Self, Self>
fn into_either(self, into_left: bool) -> Either<Self, Self>
Converts
self into a Left variant of Either<Self, Self>
if into_left is true.
Converts self into a Right variant of Either<Self, Self>
otherwise. Read moreSource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
Converts
self into a Left variant of Either<Self, Self>
if into_left(&self) returns true.
Converts self into a Right variant of Either<Self, Self>
otherwise. Read more