impl<St: Stream> Peekable<St>

fn get_ref(&self) -> &St

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

fn get_mut(&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) -> 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::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 core::pin::pin;

use futures::stream;
use futures::stream::StreamExt;

let stream = stream::iter(vec![1, 2, 3]).peekable();
let mut stream = pin!(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::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::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 core::pin::pin;

use futures::stream;
use futures::stream::StreamExt;

let stream = stream::iter(0..5).peekable();
let mut stream = pin!(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 core::pin::pin;

use futures::stream;
use futures::stream::StreamExt;

let stream = stream::iter(1..20).peekable();
let mut stream = pin!(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::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 core::pin::pin;

use futures::stream;
use futures::stream::StreamExt;

let stream = stream::iter(0..5).peekable();
let mut stream = pin!(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));
# });