Structured Concurrency Support about tokio-uring

[Ralith]

almost exactly the semantics I want (the exact semantics would require select! shenanigans).

Did you see try_join?

[matklad]

Yeah, try_join is close, but it doesn't support graceful cancellation. Here's what I came up with for my use-case (hiding behind details to not distract from the main idea of "structured concurrency works with thread-per-core"):

pub async fn try_par<E, F1, F2>(token: &CancellationToken, f1: F1, f2: F2) -> Result<(), E>
where
    F1: Future<Output = Result<(), E>>,
    F2: Future<Output = Result<(), E>>,
{
    let f1 = f1.fuse();
    let f2 = f2.fuse();
    tokio::pin!(f1, f2);

    let mut rs: [Option<Result<(), E>>; 2] = [None, None];
    loop {
        rs = match rs {
            [Some(r1), Some(r2)] => return r1.or(r2),
            _ => rs,
        };
        let (r, _) = futures_util::future::select(&mut f1, &mut f2).await.factor_first();
        if r.is_err() {
            token.cancel();
        }
        *if rs[0].is_none() { &mut rs[0] } else { &mut rs[1] } = Some(r);
    }
}

[Noah-Kennedy]

@matklad I'm not sure really that this falls within the scope of tokio-uring. IMO the goal of tokio-uring is to figure out the kinks and quirks of io_uring and work things out from an API perspective before eventually implementing the finalized API into tokio. In particular it would be great to get the API to work on the multi threaded runtime.

I think a better place for this would be in tokio-util or tokio itself. You could probably build something around localsets that would work for this.

[Noah-Kennedy]

Closing this as its probably a better question for the broader tokio project.

[matklad]

For posterity, the API along these lines was implemented in the moro crate: https://github.com/nikomatsakis/moro