Struct async_std::stream::SkipWhile

[+] Show declaration

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

[−] Expand description

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

Trait Implementations

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

[+] Show hidden undocumented items

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 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 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 fuse(self) -> Fuse<Self> where
    Self: Sized, [−]

Transforms this Stream into a "fused" Stream such that after the first time poll returns Poll::Ready(None), all future calls to poll will also return Poll::Ready(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 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<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 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 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.

[+] Expand attributes

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

This is supported on unstable only.

Transforms a stream into a collection.

impl<S: Debug, P: Debug, T: Debug> Debug for SkipWhile<S, P, T>[+]

[+] Show hidden undocumented items

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

Formats the value using the given formatter.