Rust async_trait return `impl Stream`? - rust

Question

I want to write a mock for an existing async class, without changing the original class to much.
To demonstrate my problem I took the source code from Guillaume Endignoux Blog.
I want to change it to an async trait:
use std::time::{Duration, Instant};
use async_trait::async_trait;
use futures::{StreamExt as _, Stream, stream};
use lazy_static::lazy_static;
use rand::distributions::{Uniform, Distribution as _};
use tokio::time::sleep;
lazy_static! {
static ref START_TIME: Instant = Instant::now();
}
struct Pages;
#[tokio::main]
async fn main() {
println!("First 10 pages:\n{:?}", Pages::get_n_pages(10).await);
}
#[async_trait]
trait Page {
async fn get_page(i: usize) -> Vec<usize>;
async fn get_n_pages(n: usize) -> Vec<Vec<usize>>;
fn get_pages() -> impl Stream<Item = Vec<usize>>;
}
#[async_trait]
impl Page for Pages {
async fn get_page(i: usize) -> Vec<usize> {
let millis = Uniform::from(0..10).sample(&mut rand::thread_rng());
println!(
"[{}] # get_page({}) will complete in {} ms",
START_TIME.elapsed().as_millis(),
i,
millis
);
sleep(Duration::from_millis(millis)).await;
println!(
"[{}] # get_page({}) completed",
START_TIME.elapsed().as_millis(),
i
);
(10 * i..10 * (i + 1)).collect()
}
async fn get_n_pages(n: usize) -> Vec<Vec<usize>> {
Self::get_pages().take(n).collect().await
}
fn get_pages() -> impl Stream<Item = Vec<usize>> {
stream::iter(0..).then(|i| Self::get_page(i))
}
}
But then I get the message: `impl Trait` only allowed in function and inherent method return types, not in `impl` method return.
So I change it to dyn, but then I get the message: doesn't have a size known at compile-time.
Is there a way to write async traits that return a kind of impl Stream<Item = Vec<usize>>?

Answer 1

There is an unstable feature allowing impl Trait in return positions of traits, return_position_impl_trait_in_trait. With it you can
use your initial syntax at the cost of running nightly:
#![feature(return_position_impl_trait_in_trait)]
use async_trait::async_trait;
use futures::{StreamExt as _, Stream, stream};
#[async_trait]
impl Page for Pages {
//...
fn get_pages() -> impl Stream<Item = Vec<usize>> {
stream::iter(0..).then(|i| Self::get_page(i))
}
}
Playground

Answer 2

From what I have understood, Yes, there is a way to write async traits that return a kind of impl Stream<Item = Vec>. The issue with your code is that impl Trait is not allowed in the return type of an implementation method. Instead, you can use the Box<dyn Stream<Item = Vec> as the return type. This indicates that the returned value is a boxed trait object, and it can be used to hold any type that implements the Stream trait.
Here is how you can update the code:
#[async_trait]
impl Page for Pages {
// ...
fn get_pages() -> Box<dyn Stream<Item = Vec<usize>> + Send> {
Box::new(stream::iter(0..).then(|i| Self::get_page(i)))
}
}
In this way you can use async trait and return a kind of impl Stream<Item = Vec>, but keep in mind that the + Send is required because tokio based streams are Send and that's a requirement for the Box trait object.
Don't quote me on this as my knowledge and understanding is limited but feel free to ask me any further questions.