Enum MaybeFuture

pub enum MaybeFuture<T> {
    Some(T),
    None,
}

A future which may not be present.

This is a single type which may optionally contain a future. If there is no inner future polling will always return Poll::Pending.

When the inner future is set, then MaybeFuture is polled and the inner future completes, then the poll returns the value of the inner future and MaybeFuture’s state is set to None.

The Default impl will create a MaybeFuture without an inner.

Example

One major use case for this is ergonomically disabling branches in a tokio::select!.

use std::time::Duration;

use n0_future::{task, time, MaybeFuture};

let start = time::Instant::now();

let (send, mut recv) = tokio::sync::mpsc::channel(10);
task::spawn(async move {
    // Send for the first time after 2s
    time::sleep(Duration::from_millis(2000)).await;
    let _ = send.send(()).await;
    println!("{:?}: Sent", start.elapsed());
    // Send after only 100ms
    time::sleep(Duration::from_millis(100)).await;
    let _ = send.send(()).await;
    println!("{:?}: Sent", start.elapsed());
    // Send again after only 100ms
    time::sleep(Duration::from_millis(100)).await;
    let _ = send.send(()).await;
    println!("{:?}: Sent", start.elapsed());
    // Finally send "too late" after 1100ms:
    time::sleep(Duration::from_millis(1100)).await;
    let _ = send.send(()).await;
    println!("{:?}: Sent", start.elapsed());
});

let mut timeout_fut = std::pin::pin!(MaybeFuture::default());
loop {
    tokio::select! {
        // If a timeout hasn't been set yet (a first msg hasn't been received)
        // then this won't trigger.
        _ = &mut timeout_fut => {
            println!("{:?}: Timed out!", start.elapsed());
            return;
        }
        _ = recv.recv() => {
            // Set (or reset) the timeout
            timeout_fut.as_mut().set_future(time::sleep(Duration::from_millis(1000)));
            println!("{:?}: Received!", start.elapsed());
        }
    }
}

This example prints:

2s: Sent
2s: Received!
2.1s: Sent
2.1s: Received!
2.2s: Sent
2.2s: Received!
3.2s: Timed out!

The last send times out, but it doesn’t time out before the first send.

Variants

Some(T)

The state in which it wraps a future to be polled.

None

The state in which there’s no future set, and polling will always return Poll::Pending

Implementations

impl<T> MaybeFuture<T>

pub fn set_none(self: Pin<&mut Self>)

Sets the future to None again.

pub fn set_future(self: Pin<&mut Self>, fut: T)

Sets a new future.

pub fn is_none(&self) -> bool

Returns true if the inner is empty.

pub fn is_some(&self) -> bool

Returns true if the inner contains a future.

Trait Implementations

impl<T: Debug> Debug for MaybeFuture<T>

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

Formats the value using the given formatter.

impl<T> Default for MaybeFuture<T>

fn default() -> MaybeFuture<T>

Returns the “default value” for a type.

impl<T: Future> Future for MaybeFuture<T>

type Output = <T as Future>::Output

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>

Attempts to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.

impl<'pin, T> Unpin for MaybeFuture<T>

where PinnedFieldsOf<__MaybeFuture<'pin, T>>: Unpin,