impl<St: Stream> Peekable<St>

fn get_ref(self: &Self) -> &St

Acquires a reference to the underlying sink or stream that this combinator is pulling from.

fn get_mut(self: &mut Self) -> &mut St

Acquires a mutable reference to the underlying sink or stream that this combinator is pulling from.

Note that care must be taken to avoid tampering with the state of the sink or stream which may otherwise confuse this combinator.

fn get_pin_mut(self: Pin<&mut Self>) -> Pin<&mut St>

Acquires a pinned mutable reference to the underlying sink or stream that this combinator is pulling from.

Note that care must be taken to avoid tampering with the state of the sink or stream which may otherwise confuse this combinator.

fn into_inner(self: Self) -> St

Consumes this combinator, returning the underlying sink or stream.

Note that this may discard intermediate state of this combinator, so care should be taken to avoid losing resources when this is called.

fn peek(self: Pin<&mut Self>) -> Peek<'_, St>

Produces a future which retrieves a reference to the next item in the stream, or None if the underlying stream terminates.

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

Peek retrieves a reference to the next item in the stream.

This method polls the underlying stream and return either a reference to the next item if the stream is ready or passes through any errors.

fn peek_mut(self: Pin<&mut Self>) -> PeekMut<'_, St>

Produces a future which retrieves a mutable reference to the next item in the stream, or None if the underlying stream terminates.

Examples

# futures::executor::block_on(async {
use futures::stream::{self, StreamExt};
use futures::pin_mut;

let stream = stream::iter(vec![1, 2, 3]).peekable();
pin_mut!(stream);

assert_eq!(stream.as_mut().peek_mut().await, Some(&mut 1));
assert_eq!(stream.as_mut().next().await, Some(1));

// Peek into the stream and modify the value which will be returned next
if let Some(p) = stream.as_mut().peek_mut().await {
    if *p == 2 {
        *p = 5;
    }
}

assert_eq!(stream.collect::<Vec<_>>().await, vec![5, 3]);
# });

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

Peek retrieves a mutable reference to the next item in the stream.

fn next_if<F>(self: Pin<&mut Self>, func: F) -> NextIf<'_, St, F>
where
    F: FnOnce(&<St as >::Item) -> bool

Creates a future which will consume and return the next value of this stream if a condition is true.

If func returns true for the next value of this stream, consume and return it. Otherwise, return None.

Examples

Consume a number if it's equal to 0.

# futures::executor::block_on(async {
use futures::stream::{self, StreamExt};
use futures::pin_mut;

let stream = stream::iter(0..5).peekable();
pin_mut!(stream);
// The first item of the stream is 0; consume it.
assert_eq!(stream.as_mut().next_if(|&x| x == 0).await, Some(0));
// The next item returned is now 1, so `consume` will return `false`.
assert_eq!(stream.as_mut().next_if(|&x| x == 0).await, None);
// `next_if` saves the value of the next item if it was not equal to `expected`.
assert_eq!(stream.next().await, Some(1));
# });

Consume any number less than 10.

# futures::executor::block_on(async {
use futures::stream::{self, StreamExt};
use futures::pin_mut;

let stream = stream::iter(1..20).peekable();
pin_mut!(stream);
// Consume all numbers less than 10
while stream.as_mut().next_if(|&x| x < 10).await.is_some() {}
// The next value returned will be 10
assert_eq!(stream.next().await, Some(10));
# });

fn next_if_eq<'a, T>(self: Pin<&'a mut Self>, expected: &'a T) -> NextIfEq<'a, St, T>
where
    T: ?Sized,
    <St as >::Item: PartialEq<T>

Creates a future which will consume and return the next item if it is equal to expected.

Example

Consume a number if it's equal to 0.

# futures::executor::block_on(async {
use futures::stream::{self, StreamExt};
use futures::pin_mut;

let stream = stream::iter(0..5).peekable();
pin_mut!(stream);
// The first item of the stream is 0; consume it.
assert_eq!(stream.as_mut().next_if_eq(&0).await, Some(0));
// The next item returned is now 1, so `consume` will return `false`.
assert_eq!(stream.as_mut().next_if_eq(&0).await, None);
// `next_if_eq` saves the value of the next item if it was not equal to `expected`.
assert_eq!(stream.next().await, Some(1));
# });

impl<'__pin, St: Stream> Unpin for Peekable<St>

impl<S> TryStreamExt for Peekable<St>

impl<S, Item> Sink for Peekable<S>

fn poll_ready(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), <Self as >::Error>>

fn start_send(self: Pin<&mut Self>, item: Item) -> Result<(), <Self as >::Error>

fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), <Self as >::Error>>

fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), <Self as >::Error>>

impl<S, T, E> TryStream for Peekable<St>

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

impl<S: Stream> Stream for Peekable<S>

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

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

impl<St> Freeze for Peekable<St>

impl<St> RefUnwindSafe for Peekable<St>

impl<St> Send for Peekable<St>

impl<St> Sync for Peekable<St>

impl<St> UnsafeUnpin for Peekable<St>

impl<St> UnwindSafe for Peekable<St>

impl<St: $crate::fmt::Debug + Stream> Debug for Peekable<St>

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

impl<St: Stream> FusedStream for Peekable<St>

fn is_terminated(self: &Self) -> bool

impl<T> Any for Peekable<St>

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for Peekable<St>

fn borrow(self: &Self) -> &T

impl<T> BorrowMut for Peekable<St>

fn borrow_mut(self: &mut Self) -> &mut T

impl<T> From for Peekable<St>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> StreamExt for Peekable<St>

impl<T, Item> SinkExt for Peekable<St>

impl<T, U> Into for Peekable<St>

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom for Peekable<St>

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto for Peekable<St>

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>