Is there a nicer way to use `map` and `race`?

[dignifiedquire]

Trying to use .map from futures::future::FutureExt and .race from async_std, the best thing I came up with is

let interrupt_chan = futures::future::FutureExt::map(receive.recv(), |_| IdleResult::Interrupt);
let idle_chan = futures::future::FutureExt::map(idle_stream.take(1).collect::<Vec<_>>(), |_| {
  IdleResult::Message
});

let idle_result = interrupt_chan.race(idle_chan).await;

but I would like to write

let interrupt_chan = receive.recv().map(|_| IdleResult::Interrupt);
let idle_chan = idle_stream.take(1).collect::<Vec<_>>().map(|_| {
  IdleResult::Message
});

let idle_result = interrupt_chan.race(idle_chan).await;

I believe this is a general issues with methods provided by futures vs async_std at the moment

Perhaps we should add more methods to our FutureExt trait so that people don't have to mix methods from futures and async_std?

[yoshuawuyts]

@dignifiedquire the problem you're describing here seems to be that of "remote cancellation" in general, and we've started work on that in https://github.com/async-rs/stop-token. Hopefully that will at least help in this case!

[taiki-e]

Perhaps just import without names.

use futures::future::FutureExt as _;

[dignifiedquire]

@yoshuawuyts that looks nice, I will try it out.

@taiki-e nice that actually makes it work as I would expect, though it is not intuitive that this would fix the issue (at least not to me)

[valmirjunior0088]

I ran into this same problem and the way I solved it was to create an inline async {} block, like:

let some_variable = async { some_async_task.await?; Ok(mapped_value) };

Maybe this pattern can be useful for you too, unless you have some hard requirement on the futures crate or the .map() function.