Trait amadeus_core::dist_stream::DistributedStream

#[must_use]pub trait DistributedStream {
    type Item;
    type Task: StreamTask<Item = Self::Item> + ProcessSend;
    fn size_hint(&self) -> (usize, Option<usize>);
    fn next_task(&mut self) -> Option<Self::Task>;

    fn inspect<F>(self, f: F) -> Inspect<Self, F>
    where
        F: FnMut(&Self::Item) + Clone + ProcessSend,
        Self: Sized,
    { ... }
    fn update<F>(self, f: F) -> Update<Self, F>
    where
        F: FnMut(&mut Self::Item) + Clone + ProcessSend,
        Self: Sized,
    { ... }
    fn map<B, F>(self, f: F) -> Map<Self, F>
    where
        F: FnMut(Self::Item) -> B + Clone + ProcessSend,
        Self: Sized,
    { ... }
    fn flat_map<B, F>(self, f: F) -> FlatMap<Self, F>
    where
        F: FnMut(Self::Item) -> B + Clone + ProcessSend,
        B: Stream,
        Self: Sized,
    { ... }
    fn filter<F, Fut>(self, f: F) -> Filter<Self, F>
    where
        F: FnMut(&Self::Item) -> Fut + Clone + ProcessSend,
        Fut: Future<Output = bool>,
        Self: Sized,
    { ... }
    fn chain<C>(self, chain: C) -> Chain<Self, C::DistStream>
    where
        C: IntoDistributedStream<Item = Self::Item>,
        Self: Sized,
    { ... }
#[must_use]    fn reduce<'life0, 'async_trait, P, B, R1F, R2F, R1, R2, R3>(
        self, 
        pool: &'life0 P, 
        reduce_a_factory: R1F, 
        reduce_b_factory: R2F, 
        reduce_c: R3
    ) -> Pin<Box<dyn Future<Output = B> + 'async_trait>>
    where
        P: ProcessPool,
        R1F: Factory<Item = R1> + Clone + ProcessSend,
        R2F: Factory<Item = R2>,
        R1: ReducerSend<Item = Self::Item> + ProcessSend,
        R2: ReducerProcessSend<Item = <R1 as Reducer>::Output> + ProcessSend,
        R3: Reducer<Item = <R2 as ReducerProcessSend>::Output, Output = B>,
        Self: Sized,
        P: 'async_trait,
        B: 'async_trait,
        R1F: 'async_trait,
        R2F: 'async_trait,
        R1: 'async_trait,
        R2: 'async_trait,
        R3: 'async_trait,
        'life0: 'async_trait,
        Self: 'async_trait,
    { ... }
#[must_use]    fn fork<'life0, 'async_trait, P, DistPipeA, DistPipeB, 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,
        DistPipeA: DistributedPipe<Self::Item>,
        DistPipeB: for<'a> DistributedPipe<&'a Self::Item>,
        DistSinkA: DistributedSink<DistPipeA, Self::Item, A>,
        DistSinkB: for<'a> DistributedSink<DistPipeB, &'a Self::Item, B>,
        Self::Item: 'static,
        Self: Sized,
        P: 'async_trait,
        DistPipeA: 'async_trait,
        DistPipeB: 'async_trait,
        DistSinkA: 'async_trait,
        DistSinkB: 'async_trait,
        A: 'async_trait,
        B: 'async_trait,
        'life0: 'async_trait,
        Self: 'async_trait,
    { ... }
#[must_use]    fn for_each<'life0, 'async_trait, P, F>(
        self, 
        pool: &'life0 P, 
        f: F
    ) -> Pin<Box<dyn Future<Output = ()> + 'async_trait>>
    where
        P: ProcessPool,
        F: FnMut(Self::Item) + Clone + ProcessSend,
        Self::Item: 'static,
        Self: Sized,
        P: 'async_trait,
        F: 'async_trait,
        'life0: 'async_trait,
        Self: 'async_trait,
    { ... }
#[must_use]    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,
        ID: FnMut() -> B + Clone + ProcessSend,
        F: FnMut(B, Either<Self::Item, B>) -> B + Clone + ProcessSend,
        B: ProcessSend,
        Self::Item: 'static,
        Self: Sized,
        P: 'async_trait,
        ID: 'async_trait,
        F: 'async_trait,
        B: 'async_trait,
        'life0: 'async_trait,
        Self: 'async_trait,
    { ... }
#[must_use]    fn count<'life0, 'async_trait, P>(
        self, 
        pool: &'life0 P
    ) -> Pin<Box<dyn Future<Output = usize> + 'async_trait>>
    where
        P: ProcessPool,
        Self::Item: 'static,
        Self: Sized,
        P: 'async_trait,
        'life0: 'async_trait,
        Self: 'async_trait,
    { ... }
#[must_use]    fn sum<'life0, 'async_trait, P, S>(
        self, 
        pool: &'life0 P
    ) -> Pin<Box<dyn Future<Output = S> + 'async_trait>>
    where
        P: ProcessPool,
        S: Sum<Self::Item> + Sum<S> + ProcessSend,
        Self::Item: 'static,
        Self: Sized,
        P: 'async_trait,
        S: 'async_trait,
        'life0: 'async_trait,
        Self: 'async_trait,
    { ... }
#[must_use]    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,
        F: FnMut(Self::Item, Self::Item) -> Self::Item + Clone + ProcessSend,
        Self::Item: ProcessSend,
        Self: Sized,
        P: 'async_trait,
        F: 'async_trait,
        'life0: 'async_trait,
        Self: 'async_trait,
    { ... }
#[must_use]    fn max<'life0, 'async_trait, P>(
        self, 
        pool: &'life0 P
    ) -> Pin<Box<dyn Future<Output = Option<Self::Item>> + 'async_trait>>
    where
        P: ProcessPool,
        Self::Item: Ord + ProcessSend,
        Self: Sized,
        P: 'async_trait,
        'life0: 'async_trait,
        Self: 'async_trait,
    { ... }
#[must_use]    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,
        F: FnMut(&Self::Item, &Self::Item) -> Ordering + Clone + ProcessSend,
        Self::Item: ProcessSend,
        Self: Sized,
        P: 'async_trait,
        F: 'async_trait,
        'life0: 'async_trait,
        Self: 'async_trait,
    { ... }
#[must_use]    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,
        F: FnMut(&Self::Item) -> B + Clone + ProcessSend,
        B: Ord + 'static,
        Self::Item: ProcessSend,
        Self: Sized,
        P: 'async_trait,
        F: 'async_trait,
        B: 'async_trait,
        'life0: 'async_trait,
        Self: 'async_trait,
    { ... }
#[must_use]    fn min<'life0, 'async_trait, P>(
        self, 
        pool: &'life0 P
    ) -> Pin<Box<dyn Future<Output = Option<Self::Item>> + 'async_trait>>
    where
        P: ProcessPool,
        Self::Item: Ord + ProcessSend,
        Self: Sized,
        P: 'async_trait,
        'life0: 'async_trait,
        Self: 'async_trait,
    { ... }
#[must_use]    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,
        F: FnMut(&Self::Item, &Self::Item) -> Ordering + Clone + ProcessSend,
        Self::Item: ProcessSend,
        Self: Sized,
        P: 'async_trait,
        F: 'async_trait,
        'life0: 'async_trait,
        Self: 'async_trait,
    { ... }
#[must_use]    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,
        F: FnMut(&Self::Item) -> B + Clone + ProcessSend,
        B: Ord + 'static,
        Self::Item: ProcessSend,
        Self: Sized,
        P: 'async_trait,
        F: 'async_trait,
        B: 'async_trait,
        'life0: 'async_trait,
        Self: 'async_trait,
    { ... }
#[must_use]    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,
        Self::Item: Hash + Eq + Clone + ProcessSend,
        Self: Sized,
        P: 'async_trait,
        'life0: 'async_trait,
        Self: 'async_trait,
    { ... }
#[must_use]    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,
        Self: DistributedStream<Item = (A, B)> + Sized,
        A: Hash + Eq + Clone + ProcessSend,
        B: Hash + 'static,
        P: 'async_trait,
        A: 'async_trait,
        B: 'async_trait,
        'life0: 'async_trait,
        Self: 'async_trait,
    { ... }
#[must_use]    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,
        Self::Item: ProcessSend,
        Self: Sized,
        P: 'async_trait,
        'life0: 'async_trait,
        Self: 'async_trait,
    { ... }
#[must_use]    fn all<'life0, 'async_trait, P, F>(
        self, 
        pool: &'life0 P, 
        f: F
    ) -> Pin<Box<dyn Future<Output = bool> + 'async_trait>>
    where
        P: ProcessPool,
        F: FnMut(Self::Item) -> bool + Clone + ProcessSend,
        Self::Item: 'static,
        Self: Sized,
        P: 'async_trait,
        F: 'async_trait,
        'life0: 'async_trait,
        Self: 'async_trait,
    { ... }
#[must_use]    fn any<'life0, 'async_trait, P, F>(
        self, 
        pool: &'life0 P, 
        f: F
    ) -> Pin<Box<dyn Future<Output = bool> + 'async_trait>>
    where
        P: ProcessPool,
        F: FnMut(Self::Item) -> bool + Clone + ProcessSend,
        Self::Item: 'static,
        Self: Sized,
        P: 'async_trait,
        F: 'async_trait,
        'life0: 'async_trait,
        Self: 'async_trait,
    { ... }
#[must_use]    fn collect<'life0, 'async_trait, P, B>(
        self, 
        pool: &'life0 P
    ) -> Pin<Box<dyn Future<Output = B> + 'async_trait>>
    where
        P: ProcessPool,
        B: FromDistributedStream<Self::Item>,
        B::ReduceA: ProcessSend,
        Self: Sized,
        P: 'async_trait,
        B: 'async_trait,
        'life0: 'async_trait,
        Self: 'async_trait,
    { ... }
}

Associated Types

type Item

type Task: StreamTask<Item = Self::Item> + ProcessSend

Loading content...

Required methods

fn size_hint(&self) -> (usize, Option<usize>)

fn next_task(&mut self) -> Option<Self::Task>

Loading content...

Provided methods

fn inspect<F>(self, f: F) -> Inspect<Self, F> where
    F: FnMut(&Self::Item) + Clone + ProcessSend,
    Self: Sized, 

fn update<F>(self, f: F) -> Update<Self, F> where
    F: FnMut(&mut Self::Item) + Clone + ProcessSend,
    Self: Sized, 

fn map<B, F>(self, f: F) -> Map<Self, F> where
    F: FnMut(Self::Item) -> B + Clone + ProcessSend,
    Self: Sized, 

fn flat_map<B, F>(self, f: F) -> FlatMap<Self, F> where
    F: FnMut(Self::Item) -> B + Clone + ProcessSend,
    B: Stream,
    Self: Sized, 

fn filter<F, Fut>(self, f: F) -> Filter<Self, F> where
    F: FnMut(&Self::Item) -> Fut + Clone + ProcessSend,
    Fut: Future<Output = bool>,
    Self: Sized, 

fn chain<C>(self, chain: C) -> Chain<Self, C::DistStream> where
    C: IntoDistributedStream<Item = Self::Item>,
    Self: Sized, 

#[must_use]fn reduce<'life0, 'async_trait, P, B, R1F, R2F, R1, R2, R3>(
    self,
    pool: &'life0 P,
    reduce_a_factory: R1F,
    reduce_b_factory: R2F,
    reduce_c: R3
) -> Pin<Box<dyn Future<Output = B> + 'async_trait>> where
    P: ProcessPool,
    R1F: Factory<Item = R1> + Clone + ProcessSend,
    R2F: Factory<Item = R2>,
    R1: ReducerSend<Item = Self::Item> + ProcessSend,
    R2: ReducerProcessSend<Item = <R1 as Reducer>::Output> + ProcessSend,
    R3: Reducer<Item = <R2 as ReducerProcessSend>::Output, Output = B>,
    Self: Sized,
    P: 'async_trait,
    B: 'async_trait,
    R1F: 'async_trait,
    R2F: 'async_trait,
    R1: 'async_trait,
    R2: 'async_trait,
    R3: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

#[must_use]fn fork<'life0, 'async_trait, P, DistPipeA, DistPipeB, 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,
    DistPipeA: DistributedPipe<Self::Item>,
    DistPipeB: for<'a> DistributedPipe<&'a Self::Item>,
    DistSinkA: DistributedSink<DistPipeA, Self::Item, A>,
    DistSinkB: for<'a> DistributedSink<DistPipeB, &'a Self::Item, B>,
    Self::Item: 'static,
    Self: Sized,
    P: 'async_trait,
    DistPipeA: 'async_trait,
    DistPipeB: 'async_trait,
    DistSinkA: 'async_trait,
    DistSinkB: 'async_trait,
    A: 'async_trait,
    B: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

#[must_use]fn for_each<'life0, 'async_trait, P, F>(
    self,
    pool: &'life0 P,
    f: F
) -> Pin<Box<dyn Future<Output = ()> + 'async_trait>> where
    P: ProcessPool,
    F: FnMut(Self::Item) + Clone + ProcessSend,
    Self::Item: 'static,
    Self: Sized,
    P: 'async_trait,
    F: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

#[must_use]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,
    ID: FnMut() -> B + Clone + ProcessSend,
    F: FnMut(B, Either<Self::Item, B>) -> B + Clone + ProcessSend,
    B: ProcessSend,
    Self::Item: 'static,
    Self: Sized,
    P: 'async_trait,
    ID: 'async_trait,
    F: 'async_trait,
    B: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

#[must_use]fn count<'life0, 'async_trait, P>(
    self,
    pool: &'life0 P
) -> Pin<Box<dyn Future<Output = usize> + 'async_trait>> where
    P: ProcessPool,
    Self::Item: 'static,
    Self: Sized,
    P: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

#[must_use]fn sum<'life0, 'async_trait, P, S>(
    self,
    pool: &'life0 P
) -> Pin<Box<dyn Future<Output = S> + 'async_trait>> where
    P: ProcessPool,
    S: Sum<Self::Item> + Sum<S> + ProcessSend,
    Self::Item: 'static,
    Self: Sized,
    P: 'async_trait,
    S: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

#[must_use]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,
    F: FnMut(Self::Item, Self::Item) -> Self::Item + Clone + ProcessSend,
    Self::Item: ProcessSend,
    Self: Sized,
    P: 'async_trait,
    F: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

#[must_use]fn max<'life0, 'async_trait, P>(
    self,
    pool: &'life0 P
) -> Pin<Box<dyn Future<Output = Option<Self::Item>> + 'async_trait>> where
    P: ProcessPool,
    Self::Item: Ord + ProcessSend,
    Self: Sized,
    P: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

#[must_use]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,
    F: FnMut(&Self::Item, &Self::Item) -> Ordering + Clone + ProcessSend,
    Self::Item: ProcessSend,
    Self: Sized,
    P: 'async_trait,
    F: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

#[must_use]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,
    F: FnMut(&Self::Item) -> B + Clone + ProcessSend,
    B: Ord + 'static,
    Self::Item: ProcessSend,
    Self: Sized,
    P: 'async_trait,
    F: 'async_trait,
    B: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

#[must_use]fn min<'life0, 'async_trait, P>(
    self,
    pool: &'life0 P
) -> Pin<Box<dyn Future<Output = Option<Self::Item>> + 'async_trait>> where
    P: ProcessPool,
    Self::Item: Ord + ProcessSend,
    Self: Sized,
    P: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

#[must_use]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,
    F: FnMut(&Self::Item, &Self::Item) -> Ordering + Clone + ProcessSend,
    Self::Item: ProcessSend,
    Self: Sized,
    P: 'async_trait,
    F: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

#[must_use]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,
    F: FnMut(&Self::Item) -> B + Clone + ProcessSend,
    B: Ord + 'static,
    Self::Item: ProcessSend,
    Self: Sized,
    P: 'async_trait,
    F: 'async_trait,
    B: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

#[must_use]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,
    Self::Item: Hash + Eq + Clone + ProcessSend,
    Self: Sized,
    P: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

#[must_use]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,
    Self: DistributedStream<Item = (A, B)> + Sized,
    A: Hash + Eq + Clone + ProcessSend,
    B: Hash + 'static,
    P: 'async_trait,
    A: 'async_trait,
    B: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

#[must_use]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,
    Self::Item: ProcessSend,
    Self: Sized,
    P: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

#[must_use]fn all<'life0, 'async_trait, P, F>(
    self,
    pool: &'life0 P,
    f: F
) -> Pin<Box<dyn Future<Output = bool> + 'async_trait>> where
    P: ProcessPool,
    F: FnMut(Self::Item) -> bool + Clone + ProcessSend,
    Self::Item: 'static,
    Self: Sized,
    P: 'async_trait,
    F: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

#[must_use]fn any<'life0, 'async_trait, P, F>(
    self,
    pool: &'life0 P,
    f: F
) -> Pin<Box<dyn Future<Output = bool> + 'async_trait>> where
    P: ProcessPool,
    F: FnMut(Self::Item) -> bool + Clone + ProcessSend,
    Self::Item: 'static,
    Self: Sized,
    P: 'async_trait,
    F: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

#[must_use]fn collect<'life0, 'async_trait, P, B>(
    self,
    pool: &'life0 P
) -> Pin<Box<dyn Future<Output = B> + 'async_trait>> where
    P: ProcessPool,
    B: FromDistributedStream<Self::Item>,
    B::ReduceA: ProcessSend,
    Self: Sized,
    P: 'async_trait,
    B: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Loading content...

Implementations on Foreign Types

impl<A: DistributedStream, B: DistributedStream<Item = A::Item>> DistributedStream for Sum2<A, B>

type Item = A::Item

type Task = Sum2<A::Task, B::Task>

fn size_hint(&self) -> (usize, Option<usize>)

fn next_task(&mut self) -> Option<Self::Task>

Loading content...

Implementors

impl DistributedStream for Never

type Item = Self

type Task = Self

fn size_hint(&self) -> (usize, Option<usize>)

fn next_task(&mut self) -> Option<Self::Task>

impl<A: DistributedStream, B: DistributedStream<Item = A::Item>> DistributedStream for Chain<A, B>

type Item = A::Item

type Task = ChainTask<A::Task, B::Task>

fn size_hint(&self) -> (usize, Option<usize>)

fn next_task(&mut self) -> Option<Self::Task>

impl<I: DistributedStream, F> DistributedStream for Inspect<I, F> where
    F: FnMut(&I::Item) + Clone + ProcessSend, 

type Item = I::Item

type Task = InspectTask<I::Task, F>

fn size_hint(&self) -> (usize, Option<usize>)

fn next_task(&mut self) -> Option<Self::Task>

impl<I: DistributedStream, F> DistributedStream for Update<I, F> where
    F: FnMut(&mut I::Item) + Clone + ProcessSend, 

type Item = I::Item

type Task = UpdateTask<I::Task, F>

fn size_hint(&self) -> (usize, Option<usize>)

fn next_task(&mut self) -> Option<Self::Task>

impl<I: DistributedStream, F, Fut> DistributedStream for Filter<I, F> where
    F: FnMut(&I::Item) -> Fut + Clone + ProcessSend,
    Fut: Future<Output = bool>, 

type Item = I::Item

type Task = FilterTask<I::Task, F>

fn size_hint(&self) -> (usize, Option<usize>)

fn next_task(&mut self) -> Option<Self::Task>

impl<I: DistributedStream, F, R> DistributedStream for Map<I, F> where
    F: FnMut(I::Item) -> R + Clone + ProcessSend, 

type Item = R

type Task = MapTask<I::Task, F>

fn size_hint(&self) -> (usize, Option<usize>)

fn next_task(&mut self) -> Option<Self::Task>

impl<I: DistributedStream, F, R: Stream> DistributedStream for FlatMap<I, F> where
    F: FnMut(I::Item) -> R + Clone + ProcessSend, 

type Item = R::Item

type Task = FlatMapTask<I::Task, F>

fn size_hint(&self) -> (usize, Option<usize>)

fn next_task(&mut self) -> Option<Self::Task>

impl<I: Iterator> DistributedStream for IterIter<I> where
    I::Item: ProcessSend, 

type Item = I::Item

type Task = IterIterTask<I::Item>

fn size_hint(&self) -> (usize, Option<usize>)

fn next_task(&mut self) -> Option<Self::Task>

Loading content...