Struct FlatMap 

pub struct FlatMap<Prev, Func, Iter, Meta> { /* private fields */ }

Pull combinator that maps each item to an iterator and flattens the results.

Trait Implementations

impl<Prev: Clone, Func: Clone, Iter: Clone, Meta: Clone> Clone for FlatMap<Prev, Func, Iter, Meta>

fn clone(&self) -> FlatMap<Prev, Func, Iter, Meta>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Prev: Debug, Func: Debug, Iter: Debug, Meta: Debug> Debug for FlatMap<Prev, Func, Iter, Meta>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<Prev, Func, IntoIter> Pull for FlatMap<Prev, Func, IntoIter::IntoIter, Prev::Meta>

where Prev: Pull, Func: FnMut(Prev::Item) -> IntoIter, IntoIter: IntoIterator,

type Ctx<'ctx> = <Prev as Pull>::Ctx<'ctx>

The context type required to poll this pull.

type Item = <IntoIter as IntoIterator>::Item

The type of items yielded by this pull.

type Meta = <Prev as Pull>::Meta

The metadata type associated with each item.

type CanPend = <Prev as Pull>::CanPend

Whether this pull can return PullStep::Pending.

type CanEnd = <Prev as Pull>::CanEnd

Whether this pull can return PullStep::Ended.

fn pull( self: Pin<&mut Self>, ctx: &mut Self::Ctx<'_>, ) -> PullStep<Self::Item, Self::Meta, Self::CanPend, Self::CanEnd>

Attempts to pull the next item from this stream.

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

Returns the bounds on the remaining length of the pull.

fn by_ref(&mut self) -> &mut Self

Borrows this pull, allowing it to be used by reference.

fn chain<U>(self, other: U) -> Chain<Self, U>

where Self: Sized + FusedPull<CanEnd = Yes>, U: Pull<Item = Self::Item, Meta = Self::Meta>,

Takes two pulls and creates a new pull over both in sequence.

fn enumerate(self) -> Enumerate<Self>

where Self: Sized,

Creates a pull which gives the current iteration count as well as the next value.

fn filter<P>(self, predicate: P) -> Filter<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Creates a pull which uses a closure to determine if an element should be yielded.

fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>

where Self: Sized, F: FnMut(Self::Item) -> Option<B>,

Creates a pull that both filters and maps.

fn flat_map<U, F>(self, f: F) -> FlatMap<Self, F, U::IntoIter, Self::Meta>

where Self: Sized, F: FnMut(Self::Item) -> U, U: IntoIterator,

Creates a pull that works like map, but flattens nested structure.

fn flatten( self, ) -> Flatten<Self, <Self::Item as IntoIterator>::IntoIter, Self::Meta>

where Self: Sized, Self::Item: IntoIterator,

Creates a pull that flattens nested structure.

fn flatten_stream(self) -> FlattenStream<Self, Self::Item, Self::Meta>

where Self: Sized, Self::Item: Stream,

Creates a pull that flattens items that are streams by polling each inner stream.

fn for_each<F>(self, f: F) -> ForEach<Self, F>

where Self: Sized, F: FnMut(Self::Item),

Creates a future which runs the given function on each element of a pull.

fn collect<C>(self) -> Collect<Self, C>

where Self: Sized, C: Default + Extend<Self::Item>,

Creates a future which collects all elements of a pull into a collection.

fn fuse( self, ) -> impl for<'ctx> FusedPull<Ctx<'ctx> = Self::Ctx<'ctx>, Item = Self::Item, Meta = Self::Meta, CanPend = Self::CanPend, CanEnd = Self::CanEnd>

where Self: Sized,

Creates a pull that ends after the first None.

fn inspect<F>(self, f: F) -> Inspect<Self, F>

where Self: Sized, F: FnMut(&Self::Item),

Does something with each element of a pull, passing the value on.

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

where Self: Sized, F: FnMut(Self::Item) -> B,

Takes a closure and creates a pull that calls that closure on each element.

fn send_sink<Push>(self, push: Push) -> SendSink<Self, Push>

where Self: Sized, Push: Sink<Self::Item>,

Creates a future that pulls all items and sends them into a crate::Sink.

fn send_push<Psh>(self, push: Psh) -> SendPush<Self, Psh>

where Self: Sized, Psh: Push<Self::Item, Self::Meta>,

Creates a future that pulls all items and pushes them into a crate::push::Push.

fn skip(self, n: usize) -> Skip<Self>

where Self: Sized,

Creates a pull that skips the first n elements.

fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Creates a pull that skips elements based on a predicate.

fn take(self, n: usize) -> Take<Self>

where Self: Sized,

Creates a pull that yields the first n elements, or fewer if the underlying pull ends sooner.

fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Creates a pull that yields elements based on a predicate.

fn zip<U>(self, other: U) -> Zip<Self, U>

where Self: Sized, U: Pull<Meta = Self::Meta>,

Zips two pulls together, stopping once either is exhausted.

fn zip_longest<U>(self, other: U) -> ZipLongest<Self, U>

where Self: Sized + FusedPull, U: FusedPull<Meta = Self::Meta>,

Zips two pulls together, continuing until both are exhausted.

fn next(self) -> Next<Self>

where Self: Sized,

Creates a future that resolves with the next item from this pull.

fn cross_singleton<SinglePull>( self, singleton_pull: SinglePull, ) -> CrossSingleton<Self, SinglePull, Option<SinglePull::Item>>

where Self: Sized, SinglePull: Pull, SinglePull::Item: Clone,

Crosses each item from this pull with a singleton value from another pull.

fn cross_singleton_state<SinglePull>( self, singleton_pull: SinglePull, singleton_state: &mut Option<SinglePull::Item>, ) -> CrossSingleton<Self, SinglePull, &mut Option<SinglePull::Item>>

where Self: Sized, SinglePull: Pull, SinglePull::Item: Clone,

Self::cross_singleton with external state.

fn symmetric_hash_join<Key, V1, Rhs, V2, LhsState, RhsState>( self, rhs: Rhs, lhs_state: LhsState, rhs_state: RhsState, ) -> SymmetricHashJoin<Self, Rhs, LhsState, RhsState, LhsState, RhsState>

where Self: Sized + FusedPull<Item = (Key, V1), Meta = ()>, Key: Eq + Hash + Clone, V1: Clone, V2: Clone, Rhs: FusedPull<Item = (Key, V2), Meta = ()>, LhsState: HalfJoinState<Key, V1, V2>, RhsState: HalfJoinState<Key, V2, V1>,

Available on crate feature std only.

Performs a symmetric hash join with another pull.

fn symmetric_hash_join_state<'a, Key, V1, Rhs, V2, LhsState, RhsState>( self, rhs: Rhs, lhs_state: &'a mut LhsState, rhs_state: &'a mut RhsState, ) -> SymmetricHashJoin<Self, Rhs, &'a mut LhsState, &'a mut RhsState, LhsState, RhsState>

where Self: Sized + FusedPull<Item = (Key, V1), Meta = ()>, Key: Eq + Hash + Clone, V1: Clone, V2: Clone, Rhs: FusedPull<Item = (Key, V2), Meta = ()>, LhsState: HalfJoinState<Key, V1, V2>, RhsState: HalfJoinState<Key, V2, V1>,

Available on crate feature std only.

Self::symmetric_hash_join with external state.

impl<Prev, Func, IntoIter> FusedPull for FlatMap<Prev, Func, IntoIter::IntoIter, Prev::Meta>

where Prev: FusedPull, Func: FnMut(Prev::Item) -> IntoIter, IntoIter: IntoIterator,

impl<'__pin, Prev, Func, Iter, Meta> Unpin for FlatMap<Prev, Func, Iter, Meta>

where PinnedFieldsOf<__Origin<'__pin, Prev, Func, Iter, Meta>>: Unpin,