Trait Pipe 

pub trait Pipe<Input> {
    type Output;

    // Required method
    fn poll_next(
        self: Pin<&mut Self>,
        cx: &mut Context<'_>,
        stream: Pin<&mut impl Stream<Item = Input>>,
    ) -> Poll<Option<Self::Output>>;

    // Provided methods
    fn pipe<P>(self, pipe: P) -> PipePipe<Self, P>
       where P: Pipe<Self::Output>,
             Self: Sized { ... }
    fn sink<S>(self, sink: S) -> PipeSink<Self, S>
       where S: Sink<Self::Output>,
             Self: Sized { ... }
    fn filter<F>(self, f: F) -> Filter<Self, F>
       where F: FnMut(&Self::Output) -> bool,
             Self: Sized { ... }
    fn flat_map<F, R>(self, f: F) -> FlatMap<Self, F, R>
       where F: FnMut(Self::Output) -> R,
             R: Stream,
             Self: Sized { ... }
    fn flatten(self) -> Flatten<Self, Self::Output>
       where Self::Output: Stream,
             Self: Sized { ... }
    fn map<F, R>(self, f: F) -> Map<Self, F>
       where F: FnMut(Self::Output) -> R,
             Self: Sized { ... }
}

Required Associated Types

type Output

Required Methods

fn poll_next( self: Pin<&mut Self>, cx: &mut Context<'_>, stream: Pin<&mut impl Stream<Item = Input>>, ) -> Poll<Option<Self::Output>>

Provided Methods

fn pipe<P>(self, pipe: P) -> PipePipe<Self, P>

where P: Pipe<Self::Output>, Self: Sized,

fn sink<S>(self, sink: S) -> PipeSink<Self, S>

where S: Sink<Self::Output>, Self: Sized,

fn filter<F>(self, f: F) -> Filter<Self, F>

where F: FnMut(&Self::Output) -> bool, Self: Sized,

fn flat_map<F, R>(self, f: F) -> FlatMap<Self, F, R>

where F: FnMut(Self::Output) -> R, R: Stream, Self: Sized,

fn flatten(self) -> Flatten<Self, Self::Output>

where Self::Output: Stream, Self: Sized,

fn map<F, R>(self, f: F) -> Map<Self, F>

where F: FnMut(Self::Output) -> R, Self: Sized,

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<A: Pipe<Input>, B: Pipe<Input, Output = A::Output>, Input> Pipe<Input> for Sum2<A, B>

type Output = <A as Pipe<Input>>::Output

fn poll_next( self: Pin<&mut Self>, cx: &mut Context<'_>, stream: Pin<&mut impl Stream<Item = Input>>, ) -> Poll<Option<Self::Output>>

impl<P, Input> Pipe<Input> for Pin<P>

where P: DerefMut + Unpin, P::Target: Pipe<Input>,

type Output = <<P as Deref>::Target as Pipe<Input>>::Output

fn poll_next( self: Pin<&mut Self>, cx: &mut Context<'_>, stream: Pin<&mut impl Stream<Item = Input>>, ) -> Poll<Option<Self::Output>>

impl<T, Input> Pipe<Input> for &mut T

where T: Pipe<Input> + Unpin + ?Sized,

type Output = <T as Pipe<Input>>::Output

fn poll_next( self: Pin<&mut Self>, cx: &mut Context<'_>, stream: Pin<&mut impl Stream<Item = Input>>, ) -> Poll<Option<Self::Output>>

Implementors

impl<'a, C, Input: 'a, T> Pipe<&'a Input> for ClonedTask<C>

where C: Pipe<&'a Input, Output = &'a T>, T: Clone + 'a,

type Output = T

impl<A, B, C, Input, RefAItem> Pipe<Input> for JoinStreamTaskAsync<A, B, C, RefAItem, A::Output>

where A: Pipe<Input>, B: Pipe<A::Output>, C: Pipe<RefAItem>,

type Output = Sum2<<B as Pipe<<A as Pipe<Input>>::Output>>::Output, <C as Pipe<RefAItem>>::Output>

impl<A, B, Input> Pipe<Input> for PipePipe<A, B>

where A: Pipe<Input>, B: Pipe<A::Output>,

type Output = <B as Pipe<<A as Pipe<Input>>::Output>>::Output

impl<C: Pipe<Input>, F, Input> Pipe<Input> for InspectTask<C, F>

where F: for<'a> FnMut<(&'a C::Output,), Output = ()> + Clone,

type Output = <C as Pipe<Input>>::Output

impl<C: Pipe<Input>, F, Input> Pipe<Input> for UpdateTask<C, F>

where F: for<'a> FnMut<(&'a mut C::Output,), Output = ()> + Clone,

type Output = <C as Pipe<Input>>::Output

impl<Input, C0: Pipe<Input>, C1: Pipe<Input>, C2: Pipe<Input>, C3: Pipe<Input>, C4: Pipe<Input>, C5: Pipe<Input>, C6: Pipe<Input>, C7: Pipe<Input>> Pipe<Input> for AsyncTuple8<Input, C0, C1, C2, C3, C4, C5, C6, C7>

where Input: Copy,

type Output = Sum8<<C0 as Pipe<Input>>::Output, <C1 as Pipe<Input>>::Output, <C2 as Pipe<Input>>::Output, <C3 as Pipe<Input>>::Output, <C4 as Pipe<Input>>::Output, <C5 as Pipe<Input>>::Output, <C6 as Pipe<Input>>::Output, <C7 as Pipe<Input>>::Output>

impl<Input, C0: Pipe<Input>, C1: Pipe<Input>, C2: Pipe<Input>, C3: Pipe<Input>, C4: Pipe<Input>, C5: Pipe<Input>, C6: Pipe<Input>> Pipe<Input> for AsyncTuple7<Input, C0, C1, C2, C3, C4, C5, C6>

where Input: Copy,

type Output = Sum7<<C0 as Pipe<Input>>::Output, <C1 as Pipe<Input>>::Output, <C2 as Pipe<Input>>::Output, <C3 as Pipe<Input>>::Output, <C4 as Pipe<Input>>::Output, <C5 as Pipe<Input>>::Output, <C6 as Pipe<Input>>::Output>

impl<Input, C0: Pipe<Input>, C1: Pipe<Input>, C2: Pipe<Input>, C3: Pipe<Input>, C4: Pipe<Input>, C5: Pipe<Input>> Pipe<Input> for AsyncTuple6<Input, C0, C1, C2, C3, C4, C5>

where Input: Copy,

type Output = Sum6<<C0 as Pipe<Input>>::Output, <C1 as Pipe<Input>>::Output, <C2 as Pipe<Input>>::Output, <C3 as Pipe<Input>>::Output, <C4 as Pipe<Input>>::Output, <C5 as Pipe<Input>>::Output>

impl<Input, C0: Pipe<Input>, C1: Pipe<Input>, C2: Pipe<Input>, C3: Pipe<Input>, C4: Pipe<Input>> Pipe<Input> for AsyncTuple5<Input, C0, C1, C2, C3, C4>

where Input: Copy,

type Output = Sum5<<C0 as Pipe<Input>>::Output, <C1 as Pipe<Input>>::Output, <C2 as Pipe<Input>>::Output, <C3 as Pipe<Input>>::Output, <C4 as Pipe<Input>>::Output>

impl<Input, C0: Pipe<Input>, C1: Pipe<Input>, C2: Pipe<Input>, C3: Pipe<Input>> Pipe<Input> for AsyncTuple4<Input, C0, C1, C2, C3>

where Input: Copy,

type Output = Sum4<<C0 as Pipe<Input>>::Output, <C1 as Pipe<Input>>::Output, <C2 as Pipe<Input>>::Output, <C3 as Pipe<Input>>::Output>

impl<Input, C0: Pipe<Input>, C1: Pipe<Input>, C2: Pipe<Input>> Pipe<Input> for AsyncTuple3<Input, C0, C1, C2>

where Input: Copy,

type Output = Sum3<<C0 as Pipe<Input>>::Output, <C1 as Pipe<Input>>::Output, <C2 as Pipe<Input>>::Output>

impl<Input, C0: Pipe<Input>, C1: Pipe<Input>> Pipe<Input> for AsyncTuple2<Input, C0, C1>

where Input: Copy,

type Output = Sum2<<C0 as Pipe<Input>>::Output, <C1 as Pipe<Input>>::Output>

impl<Input, C0: Pipe<Input>> Pipe<Input> for AsyncTuple1<Input, C0>

where Input:,

type Output = Sum1<<C0 as Pipe<Input>>::Output>

impl<Input> Pipe<Input> for AsyncTuple0<Input>

where Input:,

type Output = Sum0

impl<Item> Pipe<Item> for IdentityTask

type Output = Item

impl<P: Pipe<Input>, F, Input> Pipe<Input> for Filter<P, F>

where F: for<'a> FnMut<(&'a P::Output,), Output = bool>,

type Output = <P as Pipe<Input>>::Output

impl<P: Pipe<Input>, F, Input> Pipe<Input> for Map<P, F>

where F: FnMut<(P::Output,)>,

type Output = <F as FnOnce<(<P as Pipe<Input>>::Output,)>>::Output

impl<P: Pipe<Input>, F, R, Input> Pipe<Input> for FlatMap<P, F, R>

where F: FnMut<(P::Output,), Output = R>, R: Stream,

type Output = <R as Stream>::Item

impl<P: Pipe<Input>, F, R, Input> Pipe<Input> for FlatMapSync<P, F, R>

where F: FnMut<(P::Output,), Output = R>, R: Iterator,

type Output = <R as Iterator>::Item

impl<P: Pipe<Input>, F, U, Input> Pipe<Input> for FilterMapSync<P, F>

where F: FnMut<(P::Output,), Output = Option<U>>,

type Output = U

impl<P: Pipe<Input>, Input> Pipe<Input> for Flatten<P, P::Output>

where P::Output: Stream,

type Output = <<P as Pipe<Input>>::Output as Stream>::Item