Struct async_std::stream::Flatten

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, 

This is supported on unstable only.

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

Formats the value using the given formatter.

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

This is supported on unstable only.

type Item = U::Item

The type of items yielded by this stream.

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

Attempts to receive the next item from the stream.

pub fn next(&mut self) -> ImplFuture<Option<Self::Item>> where
    Self: Unpin, 

Advances the stream and returns the next value.

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

Creates a stream that yields its first n elements.

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

Creates a stream that yields elements based on a predicate.

pub fn throttle(self, d: Duration) -> Throttle<Self> where
    Self: Sized, 

Limit the amount of items yielded per timeslice in a stream.

pub fn step_by(self, step: usize) -> StepBy<Self> where
    Self: Sized, 

Creates a stream that yields each stepth element.

pub fn chain<U>(self, other: U) -> Chain<Self, U> where
    Self: Sized,
    U: Stream<Item = Self::Item> + Sized, 

Takes two streams and creates a new stream over both in sequence.

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

Creates an stream which copies all of its elements.

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

Creates an stream which copies all of its elements.

pub fn cycle(self) -> Cycle<Self> where
    Self: Clone + Sized, 

Creates a stream that yields the provided values infinitely and in order.

pub fn enumerate(self) -> Enumerate<Self> where
    Self: Sized, 

Creates a stream that gives the current element's count as well as the next value.

pub fn delay(self, dur: Duration) -> Delay<Self> where
    Self: Sized, 

Creates a stream that is delayed before it starts yielding items.

pub fn map<B, F>(self, f: F) -> Map<Self, F> where
    Self: Sized,
    F: FnMut(Self::Item) -> B, 

Takes a closure and creates a stream that calls that closure on every element of this stream.

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

A combinator that does something with each element in the stream, passing the value on.

pub fn last(self) -> ImplFuture<Option<Self::Item>> where
    Self: Sized, 

Returns the last element of the stream.

pub fn fuse(self) -> Fuse<Self> where
    Self: Sized, 

Creates a stream which ends after the first None.

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

Creates a stream that uses a predicate to determine if an element should be yielded.

pub fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where
    Self: Sized,
    U: IntoStream,
    F: FnMut(Self::Item) -> U, 

Creates an stream that works like map, but flattens nested structure.

pub fn flatten(self) -> Flatten<Self> where
    Self: Sized,
    Self::Item: IntoStream, 

Creates an stream that flattens nested structure.

pub fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Item) -> Option<B>, 

Both filters and maps a stream.

pub fn min_by_key<B, F>(self, key_by: F) -> ImplFuture<Option<Self::Item>> where
    Self: Sized,
    B: Ord,
    F: FnMut(&Self::Item) -> B, 

Returns the element that gives the minimum value with respect to the specified key function. If several elements are equally minimum, the first element is returned. If the stream is empty, None is returned.

pub fn max_by_key<B, F>(self, key_by: F) -> ImplFuture<Option<Self::Item>> where
    Self: Sized,
    B: Ord,
    F: FnMut(&Self::Item) -> B, 

Returns the element that gives the maximum value with respect to the specified key function. If several elements are equally maximum, the first element is returned. If the stream is empty, None is returned.

pub fn min_by<F>(self, compare: F) -> ImplFuture<Option<Self::Item>> where
    Self: Sized,
    F: FnMut(&Self::Item, &Self::Item) -> Ordering, 

Returns the element that gives the minimum value with respect to the specified comparison function. If several elements are equally minimum, the first element is returned. If the stream is empty, None is returned.

pub fn max(self) -> ImplFuture<Option<Self::Item>> where
    Self: Sized,
    Self::Item: Ord, 

Returns the element that gives the maximum value. If several elements are equally maximum, the first element is returned. If the stream is empty, None is returned.

pub fn min(self) -> ImplFuture<Option<Self::Item>> where
    Self: Sized,
    Self::Item: Ord, 

Returns the element that gives the minimum value. If several elements are equally minimum, the first element is returned. If the stream is empty, None is returned.

pub fn max_by<F>(self, compare: F) -> ImplFuture<Option<Self::Item>> where
    Self: Sized,
    F: FnMut(&Self::Item, &Self::Item) -> Ordering, 

Returns the element that gives the maximum value with respect to the specified comparison function. If several elements are equally maximum, the first element is returned. If the stream is empty, None is returned.

pub fn nth(&mut self, n: usize) -> ImplFuture<Option<Self::Item>> where
    Self: Unpin + Sized, 

Returns the nth element of the stream.

pub fn all<F>(&mut self, f: F) -> ImplFuture<bool> where
    Self: Unpin + Sized,
    F: FnMut(Self::Item) -> bool, 

Tests if every element of the stream matches a predicate.

pub fn find<P>(&mut self, p: P) -> ImplFuture<Option<Self::Item>> where
    Self: Unpin + Sized,
    P: FnMut(&Self::Item) -> bool, 

Searches for an element in a stream that satisfies a predicate.

pub fn find_map<F, B>(&mut self, f: F) -> ImplFuture<Option<B>> where
    Self: Unpin + Sized,
    F: FnMut(Self::Item) -> Option<B>, 

Applies function to the elements of stream and returns the first non-none result.

pub fn fold<B, F>(self, init: B, f: F) -> ImplFuture<B> where
    Self: Sized,
    F: FnMut(B, Self::Item) -> B, 

A combinator that applies a function to every element in a stream producing a single, final value.

pub fn partition<B, F>(self, f: F) -> ImplFuture<(B, B)> where
    Self: Sized,
    F: FnMut(&Self::Item) -> bool,
    B: Default + Extend<Self::Item>, 

A combinator that applies a function to every element in a stream creating two collections from it.

pub fn for_each<F>(self, f: F) -> ImplFuture<()> where
    Self: Sized,
    F: FnMut(Self::Item), 

Call a closure on each element of the stream.

pub fn any<F>(&mut self, f: F) -> ImplFuture<bool> where
    Self: Unpin + Sized,
    F: FnMut(Self::Item) -> bool, 

Tests if any element of the stream matches a predicate.

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

Borrows an stream, rather than consuming it.

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

A stream adaptor similar to fold that holds internal state and produces a new stream.

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

Combinator that skips elements based on a predicate.

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

Creates a combinator that skips the first n elements.

pub fn timeout(self, dur: Duration) -> Timeout<Self> where
    Self: Stream + Sized, 

Await a stream or times out after a duration of time.

pub fn try_fold<B, F, T, E>(
    &mut self,
    init: T,
    f: F
) -> ImplFuture<Result<T, E>> where
    Self: Unpin + Sized,
    F: FnMut(B, Self::Item) -> Result<T, E>, 

A combinator that applies a function as long as it returns successfully, producing a single, final value. Immediately returns the error when the function returns unsuccessfully.

pub fn try_for_each<F, E>(&mut self, f: F) -> ImplFuture<E> where
    Self: Unpin + Sized,
    F: FnMut(Self::Item) -> Result<(), E>, 

Applies a falliable function to each element in a stream, stopping at first error and returning it.

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

'Zips up' two streams into a single stream of pairs.

pub fn unzip<A, B, FromA, FromB>(self) -> ImplFuture<(FromA, FromB)> where
    FromA: Default + Extend<A>,
    FromB: Default + Extend<B>,
    Self: Stream<Item = (A, B)> + Sized, 

Converts an stream of pairs into a pair of containers.

pub fn collect<'a, B>(self) -> ImplFuture<B> where
    Self: Sized + 'a + Send,
    B: FromStream<Self::Item>,
    Self::Item: Send, 

Transforms a stream into a collection.

pub fn merge<U>(self, other: U) -> Merge<Self, U> where
    Self: Sized,
    U: Stream<Item = Self::Item> + Sized, 

Combines multiple streams into a single stream of all their outputs.

pub fn partial_cmp<S>(self, other: S) -> ImplFuture<Option<Ordering>> where
    Self: Sized + Stream,
    S: Stream,
    Self::Item: PartialOrd<S::Item>, 

Lexicographically compares the elements of this Stream with those of another.

pub fn position<P>(&mut self, predicate: P) -> ImplFuture<Option<usize>> where
    Self: Unpin + Sized,
    P: FnMut(Self::Item) -> bool, 

Searches for an element in a Stream that satisfies a predicate, returning its index.

pub fn cmp<S>(self, other: S) -> ImplFuture<Ordering> where
    Self: Sized + Stream,
    S: Stream,
    Self::Item: Ord, 

Lexicographically compares the elements of this Stream with those of another using 'Ord'.

pub fn count(self) -> ImplFuture<usize> where
    Self: Sized, 

Counts the number of elements in the stream.

pub fn ne<S>(self, other: S) -> ImplFuture<bool> where
    Self: Sized,
    S: Sized + Stream,
    Self::Item: PartialEq<S::Item>, 

Determines if the elements of this Stream are lexicographically not equal to those of another.

pub fn ge<S>(self, other: S) -> ImplFuture<bool> where
    Self: Sized + Stream,
    S: Stream,
    Self::Item: PartialOrd<S::Item>, 

Determines if the elements of this Stream are lexicographically greater than or equal to those of another.

pub fn eq<S>(self, other: S) -> ImplFuture<bool> where
    Self: Sized + Stream,
    S: Sized + Stream,
    Self::Item: PartialEq<S::Item>, 

Determines if the elements of this Stream are lexicographically equal to those of another.

pub fn gt<S>(self, other: S) -> ImplFuture<bool> where
    Self: Sized + Stream,
    S: Stream,
    Self::Item: PartialOrd<S::Item>, 

Determines if the elements of this Stream are lexicographically greater than those of another.

pub fn le<S>(self, other: S) -> ImplFuture<bool> where
    Self: Sized + Stream,
    S: Stream,
    Self::Item: PartialOrd<S::Item>, 

Determines if the elements of this Stream are lexicographically less or equal to those of another.

pub fn lt<S>(self, other: S) -> ImplFuture<bool> where
    Self: Sized + Stream,
    S: Stream,
    Self::Item: PartialOrd<S::Item>, 

Determines if the elements of this Stream are lexicographically less than those of another.

pub fn sum<'a, S>(self) -> ImplFuture<S> where
    Self: Sized + Stream<Item = S> + 'a,
    S: Sum<Self::Item>, 

Sums the elements of a stream.

pub fn product<'a, P>(self) -> ImplFuture<P> where
    Self: Sized + Stream<Item = P> + 'a,
    P: Product, 

Multiplies all elements of the stream.

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

This is supported on unstable only.