Struct async_std::stream::SkipWhile

pub struct SkipWhile<S, P, T> { /* fields omitted */ }

A stream to skip elements of another stream based on a predicate.

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

Trait Implementations

impl<S, P> Stream for SkipWhile<S, P, S::Item> where
    S: Stream,
    P: FnMut(&S::Item) -> bool, 

type Item = S::Item

The type of items yielded by this stream.

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

Attempts to receive the next item from the stream.

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

Advances the stream and returns the next value.

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

Creates a stream that yields its first n elements.

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

Creates a stream that yields elements based on a predicate.

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

Creates a stream that yields each stepth element.

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.

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

Creates an stream which copies all of its elements.

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

Creates an stream which copies all of its elements.

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

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

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

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

fn map<B, F>(self, f: F) -> Map<Self, F, Self::Item, B> 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.

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

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

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

Returns the last element of the stream.

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

Creates a stream which ends after the first None.

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

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

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

This is supported on unstable only.

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

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

This is supported on unstable only.

Creates an stream that flattens nested structure.

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

Both filters and maps a stream.

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

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.

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

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.

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.

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

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.

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.

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

Returns the nth element of the stream.

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.

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

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

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

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

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.

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

Call a closure on each element of the stream.

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.

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.

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

Combinator that skips elements based on a predicate.

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

Creates a combinator that skips the first n elements.

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

This is supported on unstable only.

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

fn try_fold<B, F, T, E>(self, init: T, f: F) -> ImplFuture<Result<T, E>> where
    Self: 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.

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

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

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

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

#[must_use = "if you really need to exhaust the iterator, consider `.for_each(drop)` instead (TODO)"] fn collect<'a, B>(self) -> ImplFuture<B> where
    Self: Sized + 'a,
    B: FromStream<Self::Item>, 

This is supported on unstable only.

Transforms a stream into a collection.

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

This is supported on unstable only.

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

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.

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

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

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'.

fn ne<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 not equal to those of another. # Examples ``` # fn main() { async_std::task::block_on(async { # use async_std::prelude::*; use async_std::stream;

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.

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.

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.

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.

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.

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

This is supported on unstable only.

Sums the elements of an iterator.

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

This is supported on unstable only.

Iterates over the entire iterator, multiplying all the elements

impl<'__pin, S, P, T> Unpin for SkipWhile<S, P, T> where
    __Origin<'__pin, S, P, T>: Unpin, 

impl<S: Debug, P: Debug, T: Debug> Debug for SkipWhile<S, P, T>

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

Formats the value using the given formatter.