Ignore errors in FuturesUnordered - rust

Question

I have the following setup
use futures::{
future,
stream::{self, Stream, FuturesUnordered},
};
use tokio;
fn foo(futures: FuturesUnordered<impl futures::Future<Output = std::io::Result<impl std::fmt::Binary>>>) {}
fn bar(futures: FuturesUnordered<impl futures::Future<Output = impl std::fmt::Binary>>) {}
#[tokio::main]
async fn main() {
let futures: FuturesUnordered<_> = (0..10).map(move |i| async move {
let mut delay = core::time::Duration::from_secs(rand::Rng::gen_range(&mut rand::thread_rng(), 1..3));
tokio::time::sleep(delay).await;
Ok::<i32, std::io::Error>(i) // this line can't be changed
}).collect();
// this is ok
foo(futures);
// this will not compile
bar(futures);
}
playground link
I want to be able to call the bar function with futures. Given that I can't change how futures is initialized, how do I ignore the errors in the stream and only process the elements which are not errors?
There is a similar SO question about this here: How can I remove or otherwise ignore errors when processing a stream?
But the answer uses stream::iter_ok which I think is deprecated or something?
I expected the following to work:
use futures::{
future,
stream::{self, Stream, FuturesUnordered},
StreamExt,
};
use tokio;
fn foo(futures: FuturesUnordered<impl futures::Future<Output = std::io::Result<impl std::fmt::Binary>>>) {}
async fn bar(futures: FuturesUnordered<impl futures::Future<Output = impl std::fmt::Binary>>) {
futures.for_each(|n| {
async move {
println!("Success on {:b}", n);
}
}).await
}
#[tokio::main]
async fn main() {
let futures: FuturesUnordered<_> = (0..10).map(move |i| async move {
let mut delay = core::time::Duration::from_secs(rand::Rng::gen_range(&mut rand::thread_rng(), 1..3));
tokio::time::sleep(delay).await;
Ok::<i32, std::io::Error>(i)
}).collect();
let futures = futures
.then(|r| future::ok(iter_ok::<_, ()>(r)))
.flatten();
bar(futures).await;
}
playground link

Answer 1

You can create a stream over the successful values of another stream like so:
use futures::{
stream::{self, Stream, FuturesUnordered},
StreamExt,
};
use tokio;
async fn bar(futures: impl Stream<Item = impl std::fmt::Binary>) {
futures.for_each(|n| {
async move {
println!("Success on {:b}", n);
}
}).await
}
#[tokio::main]
async fn main() {
let futures: FuturesUnordered<_> = (0..10).map(move |i| async move {
let delay = core::time::Duration::from_secs(rand::Rng::gen_range(&mut rand::thread_rng(), 1..3));
tokio::time::sleep(delay).await;
Ok::<i32, std::io::Error>(i)
}).collect();
let futures = futures
.then(|r| async { stream::iter(r.into_iter()) })
.flatten();
bar(futures).await;
}
Note: since the type returned by .then() includes the closure and thus can't be named we have to change the type of futures in bar().