How to await for the first k futures?

Question

Say we have n servers, and we only need k < n responses .

I understand futures::join_all can be used to wait for all n futures, but I want my program finish waiting after k responses.

Is there something similar to join_all that I can use to wait for the first k responses?

Answer 1

You can use streams (async iterators) for this. You can use FuturesUnordered as an unordered collection of futures, which can be used as a stream where you get each future's result in the order they complete. Then you can combine this with .take(n) to only take the first n items of the stream, and then .collect::<Vec<_>>() to wait for the stream to finish and collect the results in a Vec:

use futures::prelude::*;
use futures::stream::FuturesUnordered;

let futures = vec![
    // assume `f(n, t)` = sleep for `t` millis, then return `n`
    f(1, 1000),
    f(2, 10),
    f(3, 105),
    f(4, 40),
    f(5, 70),
    f(6, 270),
];

// create unordered collection of futures
let futures = futures.into_iter().collect::<FuturesUnordered<_>>();

// use collection as a stream, await only first 4 futures to complete
let first_4 = futures.take(4).collect::<Vec<_>>().await;

// note: any remaining futures will be cancelled automatically when the
// stream is consumed

// check with expected result, based on the order of completion
assert_eq!(first_4, vec![2, 4, 5, 3]);

Playground example

---

Edit: If you want to also get the index of completed the future, you can use this:

// create unordered collection of futures with indices
let futures = futures
        .into_iter()
        .enumerate()
        .map(|(i, fut)| fut.map(move |res| (i, res)))
        .collect::<FuturesUnordered<_>>()

Playground example