Struct async_std::stream::Flatten[−][src]

pub struct Flatten<S> where
    S: Stream,
    S::Item: IntoStream,  { /* fields omitted */ }

A stream that flattens one level of nesting in an stream of things that can be turned into streams.

This struct is created by the flatten method on Stream. See its documentation for more.

Trait Implementations

`impl<S, U> Debug for Flatten<S> where S: Debug + Stream, S::Item: IntoStream<IntoStream = U, Item = U::Item>, U: Debug + Stream,` [src]

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

`impl<S, U> Stream for Flatten<S> where S: Stream, S::Item: IntoStream<IntoStream = U, Item = U::Item>, U: Stream,` [src]

`type Item = U::Item`

Values yielded by the stream.

`fn poll_next( self: Pin<&mut Self>, cx: &mut Context<'_> ) -> Poll<Option<Self::Item>>`[src]

`pub fn size_hint(&self) -> (usize, Option<usize>)`[src]

`impl<'pin, S> Unpin for Flatten<S> where Origin<'__pin, S>: Unpin, S: Stream, S::Item: IntoStream,` [src]

Auto Trait Implementations

`impl<S> RefUnwindSafe for Flatten<S> where S: RefUnwindSafe, <<S as Stream>::Item as IntoStream>::IntoStream: RefUnwindSafe,`

`impl<S> Send for Flatten<S> where S: Send, <<S as Stream>::Item as IntoStream>::IntoStream: Send,`

`impl<S> Sync for Flatten<S> where S: Sync, <<S as Stream>::Item as IntoStream>::IntoStream: Sync,`

`impl<S> UnwindSafe for Flatten<S> where S: UnwindSafe, <<S as Stream>::Item as IntoStream>::IntoStream: UnwindSafe,`

Blanket Implementations

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`pub fn type_id(&self) -> TypeId`[src]

`impl<T> Borrow<T> for T where T: ?Sized,` [src]

`pub fn borrow(&self) -> &TⓘNotable traits for &'_ mut F impl<'_, F> Future for &'_ mut F where F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;`[src]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src]

`pub fn borrow_mut(&mut self) -> &mut TⓘNotable traits for &'_ mut F impl<'_, F> Future for &'_ mut F where F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;`[src]

`impl<T> From<T> for T`[src]

`pub fn from(t: T) -> T`[src]

`impl<T, U> Into for T where U: From<T>,` [src]

`pub fn into(self) -> U`[src]

`impl<S> StreamExt for S where S: Stream + ?Sized,` [src]

`pub fn poll_next(&mut self, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> where Self: Unpin,` [src]

`pub fn next(&mut self) -> NextFuture<'_, Self>ⓘNotable traits for NextFuture<'_, S> impl<'_, S> Future for NextFuture<'_, S> where S: Unpin + Stream + ?Sized, type Output = Option<<S as Stream>::Item>; where Self: Unpin,` [src]

`pub fn try_next<T, E>(&mut self) -> TryNextFuture<'_, Self>ⓘNotable traits for TryNextFuture<'_, S> impl<'_, T, E, S> Future for TryNextFuture<'_, S> where S: Stream<Item = Result<T, E>> + Unpin + ?Sized, type Output = Result<Option<T>, E>; where Self: Stream<Item = Result<T, E>> + Unpin,` [src]

`pub fn count(self) -> CountFuture<Self>ⓘNotable traits for CountFuture<S> impl<S> Future for CountFuture<S> where S: Stream + ?Sized, type Output = usize;`[src]

`pub fn map<T, F>(self, f: F) -> Map<Self, F> where F: FnMut(Self::Item) -> T,` [src]

`pub fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where F: FnMut(Self::Item) -> U, U: Stream,` [src]

`pub fn flatten(self) -> Flatten<Self> where Self::Item: Stream,` [src]

`pub fn then<F, Fut>(self, f: F) -> Then<Self, F, Fut> where F: FnMut(Self::Item) -> Fut, Fut: Future,` [src]

`pub fn filter(self, predicate: P) -> Filter<Self, P> where P: FnMut(&Self::Item) -> bool,` [src]

`pub fn filter_map<T, F>(self, f: F) -> FilterMap<Self, F> where F: FnMut(Self::Item) -> Option<T>,` [src]

`pub fn take(self, n: usize) -> Take<Self>`[src]

`pub fn take_while(self, predicate: P) -> TakeWhile<Self, P> where P: FnMut(&Self::Item) -> bool,` [src]

`pub fn skip(self, n: usize) -> Skip<Self>`[src]

`pub fn skip_while(self, predicate: P) -> SkipWhile<Self, P> where P: FnMut(&Self::Item) -> bool,` [src]

`pub fn step_by(self, step: usize) -> StepBy<Self>`[src]

`pub fn chain(self, other: U) -> Chain<Self, U> where U: Stream<Item = Self::Item>,` [src]

`pub fn cloned<'a, T>(self) -> Cloned<Self> where Self: Stream<Item = &'a T>, T: Clone + 'a,` [src]

`pub fn copied<'a, T>(self) -> Copied<Self> where Self: Stream<Item = &'a T>, T: Copy + 'a,` [src]

`pub fn collect<C>(self) -> CollectFuture<Self, C>ⓘNotable traits for CollectFuture<S, C> impl<S, C> Future for CollectFuture<S, C> where C: Default + Extend<<S as Stream>::Item>, S: Stream, type Output = C; where C: Default + Extend<Self::Item>,` [src]

`pub fn try_collect<T, E, C>(self) -> TryCollectFuture<Self, C>ⓘNotable traits for TryCollectFuture<S, C> impl<T, E, S, C> Future for TryCollectFuture<S, C> where C: Default + Extend<T>, S: Stream<Item = Result<T, E>>, type Output = Result<C, E>; where Self: Stream<Item = Result<T, E>>, C: Default + Extend<T>,` [src]

`pub fn partition<B, P>(self, predicate: P) -> PartitionFuture<Self, P, B>ⓘNotable traits for PartitionFuture<S, P, B> impl<S, P, B> Future for PartitionFuture<S, P, B> where P: FnMut(&<S as Stream>::Item) -> bool, B: Default + Extend<<S as Stream>::Item>, S: Stream, type Output = (B, B); where P: FnMut(&Self::Item) -> bool, B: Default + Extend<Self::Item>,` [src]

`pub fn fold<T, F>(self, init: T, f: F) -> FoldFuture<Self, F, T>ⓘNotable traits for FoldFuture<S, F, T> impl<S, F, T> Future for FoldFuture<S, F, T> where F: FnMut(T, <S as Stream>::Item) -> T, S: Stream, type Output = T; where F: FnMut(T, Self::Item) -> T,` [src]

`pub fn try_fold<T, E, F, B>( &mut self, init: B, f: F ) -> TryFoldFuture<'_, Self, F, B>ⓘNotable traits for TryFoldFuture<'a, S, F, B> impl<'a, T, E, S, F, B> Future for TryFoldFuture<'a, S, F, B> where F: FnMut(B, T) -> Result<B, E>, S: Stream<Item = Result<T, E>> + Unpin, type Output = Result<B, E>; where Self: Stream<Item = Result<T, E>> + Unpin, F: FnMut(B, T) -> Result<B, E>,` [src]

`pub fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where F: FnMut(&mut St, Self::Item) -> Option,` [src]

`pub fn fuse(self) -> Fuse<Self>`[src]

`pub fn cycle(self) -> Cycle<Self> where Self: Clone,` [src]

`pub fn enumerate(self) -> Enumerate<Self>`[src]

`pub fn inspect<F>(self, f: F) -> Inspect<Self, F> where F: FnMut(&Self::Item),` [src]

`pub fn nth(&mut self, n: usize) -> NthFuture<'_, Self>ⓘNotable traits for NthFuture<'a, S> impl<'a, S> Future for NthFuture<'a, S> where S: Stream + Unpin + ?Sized, type Output = Option<<S as Stream>::Item>; where Self: Unpin,` [src]

`pub fn last(self) -> LastFuture<Self>ⓘNotable traits for LastFuture<S> impl<S> Future for LastFuture<S> where S: Stream, type Output = Option<<S as Stream>::Item>;`[src]

`pub fn find(&mut self, predicate: P) -> FindFuture<'_, Self, P>ⓘNotable traits for FindFuture<'a, S, P> impl<'a, S, P> Future for FindFuture<'a, S, P> where P: FnMut(&<S as Stream>::Item) -> bool, S: Stream + Unpin + ?Sized, type Output = Option<<S as Stream>::Item>; where Self: Unpin, P: FnMut(&Self::Item) -> bool,` [src]

`pub fn find_map<F, B>(&mut self, f: F) -> FindMapFuture<'_, Self, F>ⓘNotable traits for FindMapFuture<'a, S, F> impl<'a, S, B, F> Future for FindMapFuture<'a, S, F> where F: FnMut(<S as Stream>::Item) -> Option, S: Stream + Unpin + ?Sized, type Output = Option; where Self: Unpin, F: FnMut(Self::Item) -> Option,` [src]

`pub fn position(&mut self, predicate: P) -> PositionFuture<'_, Self, P>ⓘNotable traits for PositionFuture<'a, S, P> impl<'a, S, P> Future for PositionFuture<'a, S, P> where P: FnMut(<S as Stream>::Item) -> bool, S: Stream + Unpin + ?Sized, type Output = Option<usize>; where Self: Unpin, P: FnMut(Self::Item) -> bool,` [src]

`pub fn all(&mut self, predicate: P) -> AllFuture<'_, Self, P>ⓘNotable traits for AllFuture<'_, S, P> impl<'_, S, P> Future for AllFuture<'_, S, P> where P: FnMut(<S as Stream>::Item) -> bool, S: Stream + Unpin + ?Sized, type Output = bool; where Self: Unpin, P: FnMut(Self::Item) -> bool,` [src]

`pub fn any(&mut self, predicate: P) -> AnyFuture<'_, Self, P>ⓘNotable traits for AnyFuture<'_, S, P> impl<'_, S, P> Future for AnyFuture<'_, S, P> where P: FnMut(<S as Stream>::Item) -> bool, S: Stream + Unpin + ?Sized, type Output = bool; where Self: Unpin, P: FnMut(Self::Item) -> bool,` [src]

`pub fn for_each<F>(self, f: F) -> ForEachFuture<Self, F>ⓘNotable traits for ForEachFuture<S, F> impl<S, F> Future for ForEachFuture<S, F> where F: FnMut(<S as Stream>::Item), S: Stream, type Output = (); where F: FnMut(Self::Item),` [src]

`pub fn try_for_each<F, E>(&mut self, f: F) -> TryForEachFuture<'_, Self, F>ⓘNotable traits for TryForEachFuture<'a, S, F> impl<'a, S, F, E> Future for TryForEachFuture<'a, S, F> where F: FnMut(<S as Stream>::Item) -> Result<(), E>, S: Stream + Unpin + ?Sized, type Output = Result<(), E>; where Self: Unpin, F: FnMut(Self::Item) -> Result<(), E>,` [src]

`pub fn zip(self, other: U) -> Zip<Self, U> where U: Stream,` [src]

`pub fn unzip<A, B, FromA, FromB>(self) -> UnzipFuture<Self, FromA, FromB>ⓘNotable traits for UnzipFuture<S, FromA, FromB> impl<S, A, B, FromA, FromB> Future for UnzipFuture<S, FromA, FromB> where FromA: Default + Extend<A>, FromB: Default + Extend, S: Stream<Item = (A, B)>, type Output = (FromA, FromB); where Self: Stream<Item = (A, B)>, FromA: Default + Extend<A>, FromB: Default + Extend,` [src]

`pub fn or<S>(self, other: S) -> Or<Self, S> where S: Stream<Item = Self::Item>,` [src]

`pub fn race<S>(self, other: S) -> Race<Self, S> where S: Stream<Item = Self::Item>,` [src]

`pub fn boxed<'a>( self ) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a + Send, Global>>ⓘNotable traits for Pin impl Future for Pin where P: Unpin + DerefMut, ::Target: Future, type Output = <::Target as Future>::Output; where Self: Send + 'a,` [src]

`pub fn boxed_local<'a>( self ) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a, Global>>ⓘNotable traits for Pin impl Future for Pin where P: Unpin + DerefMut, ::Target: Future, type Output = <::Target as Future>::Output; where Self: 'a,` [src]

`impl<T, U> TryFrom for T where U: Into<T>,` [src]

`type Error = Infallible`

The type returned in the event of a conversion error.

`pub fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>`[src]

`impl<T, U> TryInto for T where U: TryFrom<T>,` [src]

`type Error = >::Error`

The type returned in the event of a conversion error.

`pub fn try_into(self) -> Result<U, >::Error>`[src]

`impl<S, T, E> TryStream for S where S: Stream<Item = Result<T, E>> + ?Sized,` [src]

`type Ok = T`

The type of successful values yielded by this future

`type Error = E`

The type of failures yielded by this future

`pub fn try_poll_next( self: Pin<&mut S>, cx: &mut Context<'_> ) -> Poll<Option<Result<<S as TryStream>::Ok, <S as TryStream>::Error>>>`[src]

Struct async_std::stream::Flatten[−][src]

Trait Implementations

impl<S, U> Debug for Flatten<S> where S: Debug + Stream, S::Item: IntoStream<IntoStream = U, Item = U::Item>, U: Debug + Stream, [src]

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

impl<S, U> Stream for Flatten<S> where S: Stream, S::Item: IntoStream<IntoStream = U, Item = U::Item>, U: Stream, [src]

type Item = U::Item

fn poll_next( self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>>[src]

pub fn size_hint(&self) -> (usize, Option<usize>)[src]

impl<'__pin, S> Unpin for Flatten<S> where __Origin<'__pin, S>: Unpin, S: Stream, S::Item: IntoStream, [src]

Auto Trait Implementations

impl<S> RefUnwindSafe for Flatten<S> where S: RefUnwindSafe, <<S as Stream>::Item as IntoStream>::IntoStream: RefUnwindSafe,

impl<S> Send for Flatten<S> where S: Send, <<S as Stream>::Item as IntoStream>::IntoStream: Send,

impl<S> Sync for Flatten<S> where S: Sync, <<S as Stream>::Item as IntoStream>::IntoStream: Sync,

impl<S> UnwindSafe for Flatten<S> where S: UnwindSafe, <<S as Stream>::Item as IntoStream>::IntoStream: UnwindSafe,

Blanket Implementations

impl<T> Any for T where T: 'static + ?Sized, [src]

pub fn type_id(&self) -> TypeId[src]

impl<T> Borrow<T> for T where T: ?Sized, [src]

pub fn borrow(&self) -> &TⓘNotable traits for &'_ mut Fimpl<'_, F> Future for &'_ mut F where F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;[src]

Notable traits for &'_ mut F

impl<T> BorrowMut<T> for T where T: ?Sized, [src]

pub fn borrow_mut(&mut self) -> &mut TⓘNotable traits for &'_ mut Fimpl<'_, F> Future for &'_ mut F where F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;[src]

Notable traits for &'_ mut F

impl<T> From<T> for T[src]

pub fn from(t: T) -> T[src]

impl<T, U> Into<U> for T where U: From<T>, [src]

pub fn into(self) -> U[src]

impl<S> StreamExt for S where S: Stream + ?Sized, [src]

pub fn poll_next(&mut self, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> where Self: Unpin, [src]

pub fn next(&mut self) -> NextFuture<'_, Self>ⓘNotable traits for NextFuture<'_, S>impl<'_, S> Future for NextFuture<'_, S> where S: Unpin + Stream + ?Sized, type Output = Option<<S as Stream>::Item>; where Self: Unpin, [src]

Notable traits for NextFuture<'_, S>

pub fn try_next<T, E>(&mut self) -> TryNextFuture<'_, Self>ⓘNotable traits for TryNextFuture<'_, S>impl<'_, T, E, S> Future for TryNextFuture<'_, S> where S: Stream<Item = Result<T, E>> + Unpin + ?Sized, type Output = Result<Option<T>, E>; where Self: Stream<Item = Result<T, E>> + Unpin, [src]

Notable traits for TryNextFuture<'_, S>

pub fn count(self) -> CountFuture<Self>ⓘNotable traits for CountFuture<S>impl<S> Future for CountFuture<S> where S: Stream + ?Sized, type Output = usize;[src]

Notable traits for CountFuture<S>

pub fn map<T, F>(self, f: F) -> Map<Self, F> where F: FnMut(Self::Item) -> T, [src]

pub fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where F: FnMut(Self::Item) -> U, U: Stream, [src]

pub fn flatten(self) -> Flatten<Self> where Self::Item: Stream, [src]

pub fn then<F, Fut>(self, f: F) -> Then<Self, F, Fut> where F: FnMut(Self::Item) -> Fut, Fut: Future, [src]

pub fn filter<P>(self, predicate: P) -> Filter<Self, P> where P: FnMut(&Self::Item) -> bool, [src]

pub fn filter_map<T, F>(self, f: F) -> FilterMap<Self, F> where F: FnMut(Self::Item) -> Option<T>, [src]

pub fn take(self, n: usize) -> Take<Self>[src]

pub fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where P: FnMut(&Self::Item) -> bool, [src]

pub fn skip(self, n: usize) -> Skip<Self>[src]

pub fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where P: FnMut(&Self::Item) -> bool, [src]

pub fn step_by(self, step: usize) -> StepBy<Self>[src]

pub fn chain<U>(self, other: U) -> Chain<Self, U> where U: Stream<Item = Self::Item>, [src]

pub fn cloned<'a, T>(self) -> Cloned<Self> where Self: Stream<Item = &'a T>, T: Clone + 'a, [src]

pub fn copied<'a, T>(self) -> Copied<Self> where Self: Stream<Item = &'a T>, T: Copy + 'a, [src]

pub fn collect<C>(self) -> CollectFuture<Self, C>ⓘNotable traits for CollectFuture<S, C>impl<S, C> Future for CollectFuture<S, C> where C: Default + Extend<<S as Stream>::Item>, S: Stream, type Output = C; where C: Default + Extend<Self::Item>, [src]

Notable traits for CollectFuture<S, C>

Notable traits for TryCollectFuture<S, C>

Notable traits for PartitionFuture<S, P, B>

pub fn fold<T, F>(self, init: T, f: F) -> FoldFuture<Self, F, T>ⓘNotable traits for FoldFuture<S, F, T>impl<S, F, T> Future for FoldFuture<S, F, T> where F: FnMut(T, <S as Stream>::Item) -> T, S: Stream, type Output = T; where F: FnMut(T, Self::Item) -> T, [src]

Notable traits for FoldFuture<S, F, T>

Notable traits for TryFoldFuture<'a, S, F, B>

pub fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where F: FnMut(&mut St, Self::Item) -> Option<B>, [src]

pub fn fuse(self) -> Fuse<Self>[src]

pub fn cycle(self) -> Cycle<Self> where Self: Clone, [src]

pub fn enumerate(self) -> Enumerate<Self>[src]

pub fn inspect<F>(self, f: F) -> Inspect<Self, F> where F: FnMut(&Self::Item), [src]

pub fn nth(&mut self, n: usize) -> NthFuture<'_, Self>ⓘNotable traits for NthFuture<'a, S>impl<'a, S> Future for NthFuture<'a, S> where S: Stream + Unpin + ?Sized, type Output = Option<<S as Stream>::Item>; where Self: Unpin, [src]

Notable traits for NthFuture<'a, S>

pub fn last(self) -> LastFuture<Self>ⓘNotable traits for LastFuture<S>impl<S> Future for LastFuture<S> where S: Stream, type Output = Option<<S as Stream>::Item>;[src]

Notable traits for LastFuture<S>

Notable traits for FindFuture<'a, S, P>

Notable traits for FindMapFuture<'a, S, F>

Notable traits for PositionFuture<'a, S, P>

pub fn all<P>(&mut self, predicate: P) -> AllFuture<'_, Self, P>ⓘNotable traits for AllFuture<'_, S, P>impl<'_, S, P> Future for AllFuture<'_, S, P> where P: FnMut(<S as Stream>::Item) -> bool, S: Stream + Unpin + ?Sized, type Output = bool; where Self: Unpin, P: FnMut(Self::Item) -> bool, [src]

Notable traits for AllFuture<'_, S, P>

pub fn any<P>(&mut self, predicate: P) -> AnyFuture<'_, Self, P>ⓘNotable traits for AnyFuture<'_, S, P>impl<'_, S, P> Future for AnyFuture<'_, S, P> where P: FnMut(<S as Stream>::Item) -> bool, S: Stream + Unpin + ?Sized, type Output = bool; where Self: Unpin, P: FnMut(Self::Item) -> bool, [src]

Notable traits for AnyFuture<'_, S, P>

pub fn for_each<F>(self, f: F) -> ForEachFuture<Self, F>ⓘNotable traits for ForEachFuture<S, F>impl<S, F> Future for ForEachFuture<S, F> where F: FnMut(<S as Stream>::Item), S: Stream, type Output = (); where F: FnMut(Self::Item), [src]

Notable traits for ForEachFuture<S, F>

Notable traits for TryForEachFuture<'a, S, F>

pub fn zip<U>(self, other: U) -> Zip<Self, U> where U: Stream, [src]

Notable traits for UnzipFuture<S, FromA, FromB>

pub fn or<S>(self, other: S) -> Or<Self, S> where S: Stream<Item = Self::Item>, [src]

pub fn race<S>(self, other: S) -> Race<Self, S> where S: Stream<Item = Self::Item>, [src]

pub fn boxed<'a>( self) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a + Send, Global>>ⓘNotable traits for Pin<P>impl<P> Future for Pin<P> where P: Unpin + DerefMut, <P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output; where Self: Send + 'a, [src]