Trait amadeus::par_sink::ReducerAsync

#[must_use]pub trait ReducerAsync {
    type Item;
    type Output;
    fn poll_forward(
        self: Pin<&mut Self>, 
        cx: &mut Context, 
        stream: Pin<&mut impl Stream<Item = Self::Item>>
    ) -> Poll<()>;
    fn poll_output(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output>;
}

Associated Types

type Item

type Output

Loading content...

Required methods

fn poll_forward(
    self: Pin<&mut Self>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = Self::Item>>
) -> Poll<()>

fn poll_output(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output>

Loading content...

Implementations on Foreign Types

impl<P> ReducerAsync for Pin<P> where
    P: DerefMut + Unpin,
    <P as Deref>::Target: ReducerAsync, 

type Item = <<P as Deref>::Target as ReducerAsync>::Item

type Output = <<P as Deref>::Target as ReducerAsync>::Output

fn poll_forward(
    self: Pin<&mut Pin<P>>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = <Pin<P> as ReducerAsync>::Item>>
) -> Poll<()>

fn poll_output(
    self: Pin<&mut Pin<P>>,
    cx: &mut Context
) -> Poll<<Pin<P> as ReducerAsync>::Output>

impl<'_, T> ReducerAsync for &'_ mut T where
    T: ReducerAsync + Unpin + ?Sized, 

type Item = <T as ReducerAsync>::Item

type Output = <T as ReducerAsync>::Output

fn poll_forward(
    self: Pin<&mut &'_ mut T>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = <&'_ mut T as ReducerAsync>::Item>>
) -> Poll<()>

fn poll_output(
    self: Pin<&mut &'_ mut T>,
    cx: &mut Context
) -> Poll<<&'_ mut T as ReducerAsync>::Output>

Loading content...

Implementors

impl ReducerAsync for BoolAndReducer

type Item = bool

type Output = bool

fn poll_forward(
    self: Pin<&mut BoolAndReducer>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = <BoolAndReducer as ReducerAsync>::Item>>
) -> Poll<()>

fn poll_output(
    self: Pin<&mut BoolAndReducer>,
    _cx: &mut Context
) -> Poll<<BoolAndReducer as ReducerAsync>::Output>

impl ReducerAsync for BoolOrReducer

type Item = bool

type Output = bool

fn poll_forward(
    self: Pin<&mut BoolOrReducer>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = <BoolOrReducer as ReducerAsync>::Item>>
) -> Poll<()>

fn poll_output(
    self: Pin<&mut BoolOrReducer>,
    _cx: &mut Context
) -> Poll<<BoolOrReducer as ReducerAsync>::Output>

impl ReducerAsync for ReduceA0Async

type Item = Sum0

type Output = ()

fn poll_forward(
    self: Pin<&mut ReduceA0Async>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = <ReduceA0Async as ReducerAsync>::Item>>
) -> Poll<()>

fn poll_output(
    self: Pin<&mut ReduceA0Async>,
    cx: &mut Context
) -> Poll<<ReduceA0Async as ReducerAsync>::Output>

impl ReducerAsync for ReduceC0Async

type Item = ()

type Output = ()

fn poll_forward(
    self: Pin<&mut ReduceC0Async>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = <ReduceC0Async as ReducerAsync>::Item>>
) -> Poll<()>

fn poll_output(
    self: Pin<&mut ReduceC0Async>,
    cx: &mut Context
) -> Poll<<ReduceC0Async as ReducerAsync>::Output>

impl<A> ReducerAsync for ReduceA1Async<A> where
    A: ReducerAsync, 

type Item = Sum1<<A as ReducerAsync>::Item>

type Output = (<A as ReducerAsync>::Output,)

fn poll_forward(
    self: Pin<&mut ReduceA1Async<A>>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = <ReduceA1Async<A> as ReducerAsync>::Item>>
) -> Poll<()>

fn poll_output(
    self: Pin<&mut ReduceA1Async<A>>,
    cx: &mut Context
) -> Poll<<ReduceA1Async<A> as ReducerAsync>::Output>

impl<A> ReducerAsync for ReduceC1Async<A> where
    A: ReducerAsync, 

type Item = (<A as ReducerAsync>::Item,)

type Output = (<A as ReducerAsync>::Output,)

fn poll_forward(
    self: Pin<&mut ReduceC1Async<A>>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = <ReduceC1Async<A> as ReducerAsync>::Item>>
) -> Poll<()>

fn poll_output(
    self: Pin<&mut ReduceC1Async<A>>,
    cx: &mut Context
) -> Poll<<ReduceC1Async<A> as ReducerAsync>::Output>

impl<A, B> ReducerAsync for ReduceA2Async<A, B> where
    A: ReducerAsync,
    B: ReducerAsync, 

type Item = Sum2<<A as ReducerAsync>::Item, <B as ReducerAsync>::Item>

type Output = (<A as ReducerAsync>::Output, <B as ReducerAsync>::Output)

fn poll_forward(
    self: Pin<&mut ReduceA2Async<A, B>>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = <ReduceA2Async<A, B> as ReducerAsync>::Item>>
) -> Poll<()>

fn poll_output(
    self: Pin<&mut ReduceA2Async<A, B>>,
    cx: &mut Context
) -> Poll<<ReduceA2Async<A, B> as ReducerAsync>::Output>

impl<A, B> ReducerAsync for ReduceC2Async<A, B> where
    A: ReducerAsync,
    B: ReducerAsync, 

type Item = (<A as ReducerAsync>::Item, <B as ReducerAsync>::Item)

type Output = (<A as ReducerAsync>::Output, <B as ReducerAsync>::Output)

fn poll_forward(
    self: Pin<&mut ReduceC2Async<A, B>>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = <ReduceC2Async<A, B> as ReducerAsync>::Item>>
) -> Poll<()>

fn poll_output(
    self: Pin<&mut ReduceC2Async<A, B>>,
    cx: &mut Context
) -> Poll<<ReduceC2Async<A, B> as ReducerAsync>::Output>

impl<A, B, C> ReducerAsync for ReduceA3Async<A, B, C> where
    A: ReducerAsync,
    B: ReducerAsync,
    C: ReducerAsync, 

type Item = Sum3<<A as ReducerAsync>::Item, <B as ReducerAsync>::Item, <C as ReducerAsync>::Item>

type Output = (<A as ReducerAsync>::Output, <B as ReducerAsync>::Output, <C as ReducerAsync>::Output)

fn poll_forward(
    self: Pin<&mut ReduceA3Async<A, B, C>>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = <ReduceA3Async<A, B, C> as ReducerAsync>::Item>>
) -> Poll<()>

fn poll_output(
    self: Pin<&mut ReduceA3Async<A, B, C>>,
    cx: &mut Context
) -> Poll<<ReduceA3Async<A, B, C> as ReducerAsync>::Output>

impl<A, B, C> ReducerAsync for ReduceC3Async<A, B, C> where
    A: ReducerAsync,
    B: ReducerAsync,
    C: ReducerAsync, 

type Item = (<A as ReducerAsync>::Item, <B as ReducerAsync>::Item, <C as ReducerAsync>::Item)

type Output = (<A as ReducerAsync>::Output, <B as ReducerAsync>::Output, <C as ReducerAsync>::Output)

fn poll_forward(
    self: Pin<&mut ReduceC3Async<A, B, C>>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = <ReduceC3Async<A, B, C> as ReducerAsync>::Item>>
) -> Poll<()>

fn poll_output(
    self: Pin<&mut ReduceC3Async<A, B, C>>,
    cx: &mut Context
) -> Poll<<ReduceC3Async<A, B, C> as ReducerAsync>::Output>

impl<A, B, C, D> ReducerAsync for ReduceA4Async<A, B, C, D> where
    A: ReducerAsync,
    B: ReducerAsync,
    C: ReducerAsync,
    D: ReducerAsync, 

type Item = Sum4<<A as ReducerAsync>::Item, <B as ReducerAsync>::Item, <C as ReducerAsync>::Item, <D as ReducerAsync>::Item>

type Output = (<A as ReducerAsync>::Output, <B as ReducerAsync>::Output, <C as ReducerAsync>::Output, <D as ReducerAsync>::Output)

fn poll_forward(
    self: Pin<&mut ReduceA4Async<A, B, C, D>>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = <ReduceA4Async<A, B, C, D> as ReducerAsync>::Item>>
) -> Poll<()>

fn poll_output(
    self: Pin<&mut ReduceA4Async<A, B, C, D>>,
    cx: &mut Context
) -> Poll<<ReduceA4Async<A, B, C, D> as ReducerAsync>::Output>

impl<A, B, C, D> ReducerAsync for ReduceC4Async<A, B, C, D> where
    A: ReducerAsync,
    B: ReducerAsync,
    C: ReducerAsync,
    D: ReducerAsync, 

type Item = (<A as ReducerAsync>::Item, <B as ReducerAsync>::Item, <C as ReducerAsync>::Item, <D as ReducerAsync>::Item)

type Output = (<A as ReducerAsync>::Output, <B as ReducerAsync>::Output, <C as ReducerAsync>::Output, <D as ReducerAsync>::Output)

fn poll_forward(
    self: Pin<&mut ReduceC4Async<A, B, C, D>>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = <ReduceC4Async<A, B, C, D> as ReducerAsync>::Item>>
) -> Poll<()>

fn poll_output(
    self: Pin<&mut ReduceC4Async<A, B, C, D>>,
    cx: &mut Context
) -> Poll<<ReduceC4Async<A, B, C, D> as ReducerAsync>::Output>

impl<A, B, C, D, E> ReducerAsync for ReduceA5Async<A, B, C, D, E> where
    A: ReducerAsync,
    B: ReducerAsync,
    C: ReducerAsync,
    D: ReducerAsync,
    E: ReducerAsync, 

type Item = Sum5<<A as ReducerAsync>::Item, <B as ReducerAsync>::Item, <C as ReducerAsync>::Item, <D as ReducerAsync>::Item, <E as ReducerAsync>::Item>

type Output = (<A as ReducerAsync>::Output, <B as ReducerAsync>::Output, <C as ReducerAsync>::Output, <D as ReducerAsync>::Output, <E as ReducerAsync>::Output)

fn poll_forward(
    self: Pin<&mut ReduceA5Async<A, B, C, D, E>>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = <ReduceA5Async<A, B, C, D, E> as ReducerAsync>::Item>>
) -> Poll<()>

fn poll_output(
    self: Pin<&mut ReduceA5Async<A, B, C, D, E>>,
    cx: &mut Context
) -> Poll<<ReduceA5Async<A, B, C, D, E> as ReducerAsync>::Output>

impl<A, B, C, D, E> ReducerAsync for ReduceC5Async<A, B, C, D, E> where
    A: ReducerAsync,
    B: ReducerAsync,
    C: ReducerAsync,
    D: ReducerAsync,
    E: ReducerAsync, 

type Item = (<A as ReducerAsync>::Item, <B as ReducerAsync>::Item, <C as ReducerAsync>::Item, <D as ReducerAsync>::Item, <E as ReducerAsync>::Item)

type Output = (<A as ReducerAsync>::Output, <B as ReducerAsync>::Output, <C as ReducerAsync>::Output, <D as ReducerAsync>::Output, <E as ReducerAsync>::Output)

fn poll_forward(
    self: Pin<&mut ReduceC5Async<A, B, C, D, E>>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = <ReduceC5Async<A, B, C, D, E> as ReducerAsync>::Item>>
) -> Poll<()>

fn poll_output(
    self: Pin<&mut ReduceC5Async<A, B, C, D, E>>,
    cx: &mut Context
) -> Poll<<ReduceC5Async<A, B, C, D, E> as ReducerAsync>::Output>

impl<A, B, C, D, E, F> ReducerAsync for ReduceA6Async<A, B, C, D, E, F> where
    A: ReducerAsync,
    B: ReducerAsync,
    C: ReducerAsync,
    D: ReducerAsync,
    E: ReducerAsync,
    F: ReducerAsync, 

type Item = Sum6<<A as ReducerAsync>::Item, <B as ReducerAsync>::Item, <C as ReducerAsync>::Item, <D as ReducerAsync>::Item, <E as ReducerAsync>::Item, <F as ReducerAsync>::Item>

type Output = (<A as ReducerAsync>::Output, <B as ReducerAsync>::Output, <C as ReducerAsync>::Output, <D as ReducerAsync>::Output, <E as ReducerAsync>::Output, <F as ReducerAsync>::Output)

fn poll_forward(
    self: Pin<&mut ReduceA6Async<A, B, C, D, E, F>>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = <ReduceA6Async<A, B, C, D, E, F> as ReducerAsync>::Item>>
) -> Poll<()>

fn poll_output(
    self: Pin<&mut ReduceA6Async<A, B, C, D, E, F>>,
    cx: &mut Context
) -> Poll<<ReduceA6Async<A, B, C, D, E, F> as ReducerAsync>::Output>

impl<A, B, C, D, E, F> ReducerAsync for ReduceC6Async<A, B, C, D, E, F> where
    A: ReducerAsync,
    B: ReducerAsync,
    C: ReducerAsync,
    D: ReducerAsync,
    E: ReducerAsync,
    F: ReducerAsync, 

type Item = (<A as ReducerAsync>::Item, <B as ReducerAsync>::Item, <C as ReducerAsync>::Item, <D as ReducerAsync>::Item, <E as ReducerAsync>::Item, <F as ReducerAsync>::Item)

type Output = (<A as ReducerAsync>::Output, <B as ReducerAsync>::Output, <C as ReducerAsync>::Output, <D as ReducerAsync>::Output, <E as ReducerAsync>::Output, <F as ReducerAsync>::Output)

fn poll_forward(
    self: Pin<&mut ReduceC6Async<A, B, C, D, E, F>>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = <ReduceC6Async<A, B, C, D, E, F> as ReducerAsync>::Item>>
) -> Poll<()>

fn poll_output(
    self: Pin<&mut ReduceC6Async<A, B, C, D, E, F>>,
    cx: &mut Context
) -> Poll<<ReduceC6Async<A, B, C, D, E, F> as ReducerAsync>::Output>

impl<A, B, C, D, E, F, G> ReducerAsync for ReduceA7Async<A, B, C, D, E, F, G> where
    A: ReducerAsync,
    B: ReducerAsync,
    C: ReducerAsync,
    D: ReducerAsync,
    E: ReducerAsync,
    F: ReducerAsync,
    G: ReducerAsync, 

type Item = Sum7<<A as ReducerAsync>::Item, <B as ReducerAsync>::Item, <C as ReducerAsync>::Item, <D as ReducerAsync>::Item, <E as ReducerAsync>::Item, <F as ReducerAsync>::Item, <G as ReducerAsync>::Item>

type Output = (<A as ReducerAsync>::Output, <B as ReducerAsync>::Output, <C as ReducerAsync>::Output, <D as ReducerAsync>::Output, <E as ReducerAsync>::Output, <F as ReducerAsync>::Output, <G as ReducerAsync>::Output)

fn poll_forward(
    self: Pin<&mut ReduceA7Async<A, B, C, D, E, F, G>>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = <ReduceA7Async<A, B, C, D, E, F, G> as ReducerAsync>::Item>>
) -> Poll<()>

fn poll_output(
    self: Pin<&mut ReduceA7Async<A, B, C, D, E, F, G>>,
    cx: &mut Context
) -> Poll<<ReduceA7Async<A, B, C, D, E, F, G> as ReducerAsync>::Output>

impl<A, B, C, D, E, F, G> ReducerAsync for ReduceC7Async<A, B, C, D, E, F, G> where
    A: ReducerAsync,
    B: ReducerAsync,
    C: ReducerAsync,
    D: ReducerAsync,
    E: ReducerAsync,
    F: ReducerAsync,
    G: ReducerAsync, 

type Item = (<A as ReducerAsync>::Item, <B as ReducerAsync>::Item, <C as ReducerAsync>::Item, <D as ReducerAsync>::Item, <E as ReducerAsync>::Item, <F as ReducerAsync>::Item, <G as ReducerAsync>::Item)

type Output = (<A as ReducerAsync>::Output, <B as ReducerAsync>::Output, <C as ReducerAsync>::Output, <D as ReducerAsync>::Output, <E as ReducerAsync>::Output, <F as ReducerAsync>::Output, <G as ReducerAsync>::Output)

fn poll_forward(
    self: Pin<&mut ReduceC7Async<A, B, C, D, E, F, G>>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = <ReduceC7Async<A, B, C, D, E, F, G> as ReducerAsync>::Item>>
) -> Poll<()>

fn poll_output(
    self: Pin<&mut ReduceC7Async<A, B, C, D, E, F, G>>,
    cx: &mut Context
) -> Poll<<ReduceC7Async<A, B, C, D, E, F, G> as ReducerAsync>::Output>

impl<A, B, C, D, E, F, G, H> ReducerAsync for ReduceA8Async<A, B, C, D, E, F, G, H> where
    A: ReducerAsync,
    B: ReducerAsync,
    C: ReducerAsync,
    D: ReducerAsync,
    E: ReducerAsync,
    F: ReducerAsync,
    G: ReducerAsync,
    H: ReducerAsync, 

type Item = Sum8<<A as ReducerAsync>::Item, <B as ReducerAsync>::Item, <C as ReducerAsync>::Item, <D as ReducerAsync>::Item, <E as ReducerAsync>::Item, <F as ReducerAsync>::Item, <G as ReducerAsync>::Item, <H as ReducerAsync>::Item>

type Output = (<A as ReducerAsync>::Output, <B as ReducerAsync>::Output, <C as ReducerAsync>::Output, <D as ReducerAsync>::Output, <E as ReducerAsync>::Output, <F as ReducerAsync>::Output, <G as ReducerAsync>::Output, <H as ReducerAsync>::Output)

fn poll_forward(
    self: Pin<&mut ReduceA8Async<A, B, C, D, E, F, G, H>>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = <ReduceA8Async<A, B, C, D, E, F, G, H> as ReducerAsync>::Item>>
) -> Poll<()>

fn poll_output(
    self: Pin<&mut ReduceA8Async<A, B, C, D, E, F, G, H>>,
    cx: &mut Context
) -> Poll<<ReduceA8Async<A, B, C, D, E, F, G, H> as ReducerAsync>::Output>

impl<A, B, C, D, E, F, G, H> ReducerAsync for ReduceC8Async<A, B, C, D, E, F, G, H> where
    A: ReducerAsync,
    B: ReducerAsync,
    C: ReducerAsync,
    D: ReducerAsync,
    E: ReducerAsync,
    F: ReducerAsync,
    G: ReducerAsync,
    H: ReducerAsync, 

type Item = (<A as ReducerAsync>::Item, <B as ReducerAsync>::Item, <C as ReducerAsync>::Item, <D as ReducerAsync>::Item, <E as ReducerAsync>::Item, <F as ReducerAsync>::Item, <G as ReducerAsync>::Item, <H as ReducerAsync>::Item)

type Output = (<A as ReducerAsync>::Output, <B as ReducerAsync>::Output, <C as ReducerAsync>::Output, <D as ReducerAsync>::Output, <E as ReducerAsync>::Output, <F as ReducerAsync>::Output, <G as ReducerAsync>::Output, <H as ReducerAsync>::Output)

fn poll_forward(
    self: Pin<&mut ReduceC8Async<A, B, C, D, E, F, G, H>>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = <ReduceC8Async<A, B, C, D, E, F, G, H> as ReducerAsync>::Item>>
) -> Poll<()>

fn poll_output(
    self: Pin<&mut ReduceC8Async<A, B, C, D, E, F, G, H>>,
    cx: &mut Context
) -> Poll<<ReduceC8Async<A, B, C, D, E, F, G, H> as ReducerAsync>::Output>

impl<A, C> ReducerAsync for FolderSyncReducerAsync<A, C, <C as FolderSync<A>>::Output> where
    C: FolderSync<A>, 

type Item = A

type Output = <C as FolderSync<A>>::Output

fn poll_forward(
    self: Pin<&mut FolderSyncReducerAsync<A, C, <C as FolderSync<A>>::Output>>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = <FolderSyncReducerAsync<A, C, <C as FolderSync<A>>::Output> as ReducerAsync>::Item>>
) -> Poll<()>

fn poll_output(
    self: Pin<&mut FolderSyncReducerAsync<A, C, <C as FolderSync<A>>::Output>>,
    _cx: &mut Context
) -> Poll<<FolderSyncReducerAsync<A, C, <C as FolderSync<A>>::Output> as ReducerAsync>::Output>

impl<A, F> ReducerAsync for AllReducer<A, F> where
    F: FnMut(A) -> bool, 

type Item = A

type Output = bool

fn poll_forward(
    self: Pin<&mut AllReducer<A, F>>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = <AllReducer<A, F> as ReducerAsync>::Item>>
) -> Poll<()>

fn poll_output(
    self: Pin<&mut AllReducer<A, F>>,
    _cx: &mut Context
) -> Poll<<AllReducer<A, F> as ReducerAsync>::Output>

impl<A, F> ReducerAsync for AnyReducer<A, F> where
    F: FnMut(A) -> bool, 

type Item = A

type Output = bool

fn poll_forward(
    self: Pin<&mut AnyReducer<A, F>>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = <AnyReducer<A, F> as ReducerAsync>::Item>>
) -> Poll<()>

fn poll_output(
    self: Pin<&mut AnyReducer<A, F>>,
    _cx: &mut Context
) -> Poll<<AnyReducer<A, F> as ReducerAsync>::Output>

impl<A, F> ReducerAsync for ForEachReducer<A, F> where
    F: FnMut(A) + Clone, 

type Item = A

type Output = ()

fn poll_forward(
    self: Pin<&mut ForEachReducer<A, F>>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = <ForEachReducer<A, F> as ReducerAsync>::Item>>
) -> Poll<()>

fn poll_output(
    self: Pin<&mut ForEachReducer<A, F>>,
    _cx: &mut Context
) -> Poll<<ForEachReducer<A, F> as ReducerAsync>::Output>

impl<A, T> ReducerAsync for PushReducer<A, T> where
    T: Extend<A>, 

type Item = A

type Output = T

fn poll_forward(
    self: Pin<&mut PushReducer<A, T>>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = <PushReducer<A, T> as ReducerAsync>::Item>>
) -> Poll<()>

fn poll_output(
    self: Pin<&mut PushReducer<A, T>>,
    _cx: &mut Context
) -> Poll<<PushReducer<A, T> as ReducerAsync>::Output>

impl<A, T, B> ReducerAsync for ExtendReducer<A, T> where
    A: IntoIterator<Item = B>,
    T: Extend<B>, 

type Item = A

type Output = T

fn poll_forward(
    self: Pin<&mut ExtendReducer<A, T>>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = <ExtendReducer<A, T> as ReducerAsync>::Item>>
) -> Poll<()>

fn poll_output(
    self: Pin<&mut ExtendReducer<A, T>>,
    _cx: &mut Context
) -> Poll<<ExtendReducer<A, T> as ReducerAsync>::Output>

impl<R> ReducerAsync for OptionReducer<R> where
    R: ReducerAsync, 

type Item = Option<<R as ReducerAsync>::Item>

type Output = Option<<R as ReducerAsync>::Output>

fn poll_forward(
    self: Pin<&mut OptionReducer<R>>,
    _cx: &mut Context,
    _stream: Pin<&mut impl Stream<Item = <OptionReducer<R> as ReducerAsync>::Item>>
) -> Poll<()>

fn poll_output(
    self: Pin<&mut OptionReducer<R>>,
    cx: &mut Context
) -> Poll<<OptionReducer<R> as ReducerAsync>::Output>

impl<R, E> ReducerAsync for ResultReducerAsync<R, E> where
    R: ReducerAsync, 

type Item = Result<<R as ReducerAsync>::Item, E>

type Output = Result<<R as ReducerAsync>::Output, E>

fn poll_forward(
    self: Pin<&mut ResultReducerAsync<R, E>>,
    _cx: &mut Context,
    _stream: Pin<&mut impl Stream<Item = <ResultReducerAsync<R, E> as ReducerAsync>::Item>>
) -> Poll<()>

fn poll_output(
    self: Pin<&mut ResultReducerAsync<R, E>>,
    cx: &mut Context
) -> Poll<<ResultReducerAsync<R, E> as ReducerAsync>::Output>

impl<R, T> ReducerAsync for IntoReducer<R, T> where
    R: ReducerAsync,
    <R as ReducerAsync>::Output: Into<T>, 

type Item = <R as ReducerAsync>::Item

type Output = T

fn poll_forward(
    self: Pin<&mut IntoReducer<R, T>>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = <IntoReducer<R, T> as ReducerAsync>::Item>>
) -> Poll<()>

fn poll_output(
    self: Pin<&mut IntoReducer<R, T>>,
    cx: &mut Context
) -> Poll<<IntoReducer<R, T> as ReducerAsync>::Output>

Loading content...