Struct DurableFuturesUnordered 

pub struct DurableFuturesUnordered<F> { /* private fields */ }

A collection of durable futures that yields results as they complete, similar to futures::stream::FuturesUnordered.

Each future is assigned a stable index when pushed, which is returned alongside the result from next so you can correlate outputs with inputs.

Example

let labels = vec!["fast", "medium", "slow"];
let durations = vec![1, 2, 3];

let mut futures = DurableFuturesUnordered::new();
for secs in &durations {
    futures.push(ctx.sleep(Duration::from_secs(*secs)));
}

while let Some((index, result)) = futures.next().await? {
    result?;
    println!("{} timer done!", labels[index]);
}

You can also collect into it from an iterator:

let durations = vec![1, 2, 3];
let mut futures: DurableFuturesUnordered<_> = durations
    .iter()
    .map(|secs| ctx.sleep(Duration::from_secs(*secs)))
    .collect();

while let Some((index, result)) = futures.next().await? {
    result?;
}

Implementations

impl<F> DurableFuturesUnordered<F>

pub fn new() -> Self

Create an empty collection.

pub fn push(&mut self, future: F) -> usize

Add a durable future to the collection. Returns the stable index assigned to this future.

pub fn is_empty(&self) -> bool

Returns true if there are no remaining futures.

pub fn len(&self) -> usize

Returns the number of remaining futures.

impl<F: DurableFuture> DurableFuturesUnordered<F>

pub async fn next( &mut self, ) -> Result<Option<(usize, F::Output)>, TerminalError>

Await the next completed future.

Returns Ok(None) if there are no remaining futures. Returns Err(TerminalError) if the invocation was cancelled. Returns Ok(Some((index, output))) with the stable index and output of the next completed future.

Trait Implementations

impl<F> Default for DurableFuturesUnordered<F>

fn default() -> Self

Returns the “default value” for a type.

impl<F> FromIterator<F> for DurableFuturesUnordered<F>

fn from_iter<I: IntoIterator<Item = F>>(iter: I) -> Self

Creates a value from an iterator.