Trait amadeus::dist_iter::Consumer

pub trait Consumer {
    type Item;
    fn run(self, i: &mut impl FnMut(Self::Item) -> bool) -> bool;
}

Associated Types

type Item

Loading content...

Required methods

fn run(self, i: &mut impl FnMut(Self::Item) -> bool) -> bool

Loading content...

Implementations on Foreign Types

impl<A, B> Consumer for Sum2<A, B> where
    A: Consumer,
    B: Consumer<Item = <A as Consumer>::Item>, 

type Item = <A as Consumer>::Item

fn run(self, i: &mut impl FnMut(<Sum2<A, B> as Consumer>::Item) -> bool) -> bool

impl<T> Consumer for ImplConsumer<T> where
    T: 'static, 

type Item = T

fn run(
    self,
    _i: &mut impl FnMut(<ImplConsumer<T> as Consumer>::Item) -> bool
) -> bool

Loading content...

Implementors

impl Consumer for Never

type Item = Never

fn run(self, &mut impl FnMut(<Never as Consumer>::Item) -> bool) -> bool

impl<A, B> Consumer for ChainConsumer<A, B> where
    A: Consumer,
    B: Consumer<Item = <A as Consumer>::Item>, 

type Item = <A as Consumer>::Item

fn run(
    self,
    i: &mut impl FnMut(<ChainConsumer<A, B> as Consumer>::Item) -> bool
) -> bool

impl<C, F> Consumer for FilterConsumer<C, F> where
    C: Consumer,
    F: FnMut(&<C as Consumer>::Item) -> bool + Clone, 

type Item = <C as Consumer>::Item

fn run(
    self,
    i: &mut impl FnMut(<FilterConsumer<C, F> as Consumer>::Item) -> bool
) -> bool

impl<C, F> Consumer for InspectConsumer<C, F> where
    C: Consumer,
    F: FnMut(&<C as Consumer>::Item) + Clone, 

type Item = <C as Consumer>::Item

fn run(
    self,
    i: &mut impl FnMut(<InspectConsumer<C, F> as Consumer>::Item) -> bool
) -> bool

impl<C, F> Consumer for UpdateConsumer<C, F> where
    C: Consumer,
    F: FnMut(&mut <C as Consumer>::Item) + Clone, 

type Item = <C as Consumer>::Item

fn run(
    self,
    i: &mut impl FnMut(<UpdateConsumer<C, F> as Consumer>::Item) -> bool
) -> bool

impl<C, F, R> Consumer for FlatMapConsumer<C, F> where
    C: Consumer,
    F: FnMut(<C as Consumer>::Item) -> R + Clone,
    R: IntoIterator, 

type Item = <R as IntoIterator>::Item

fn run(
    self,
    i: &mut impl FnMut(<FlatMapConsumer<C, F> as Consumer>::Item) -> bool
) -> bool

impl<C, F, R> Consumer for MapConsumer<C, F> where
    C: Consumer,
    F: FnMut(<C as Consumer>::Item) -> R + Clone, 

type Item = R

fn run(
    self,
    i: &mut impl FnMut(<MapConsumer<C, F> as Consumer>::Item) -> bool
) -> bool

impl<I, T, E, U> Consumer for IntoConsumer<I, U> where
    I: Consumer<Item = Result<T, E>>,
    T: Into<U>, 

type Item = Result<U, E>

fn run(self, i: &mut impl FnMut(Self::Item) -> bool) -> bool

impl<T> Consumer for IterIterConsumer<T>

type Item = T

fn run(
    self,
    i: &mut impl FnMut(<IterIterConsumer<T> as Consumer>::Item) -> bool
) -> bool

Loading content...