This is a no_std
compatible library to author a Future
with Stream
implemented.
You can author simply with await
and yield
.
A nightly feature coroutines
is required.
#![feature(coroutines)]
use stream_future::stream;
#[derive(Debug)]
enum Prog {
Stage1,
Stage2,
}
#[stream(Prog)]
async fn foo() -> Result<i32> {
yield Prog::Stage1;
// some works...
yield Prog::Stage2;
// some other works...
Ok(0)
}
use tokio_stream::StreamExt;
let bar = foo();
tokio::pin!(bar);
while let Some(prog) = bar.next().await {
println!("{:?}", prog);
}
let bar = bar.await?;
assert_eq!(bar, 0);
#![feature(coroutines)]
use stream_future::try_stream;
#[derive(Debug)]
enum Prog {
Stage1,
Stage2,
}
#[try_stream(Prog)]
async fn foo() -> Result<()> {
yield Prog::Stage1;
// some works...
yield Prog::Stage2;
// some other works...
Ok(())
}
let bar = foo();
tokio::pin!(bar);
while let Some(prog) = bar.try_next().await? {
println!("{:?}", prog);
}
You can specify the yield type in the attribute. Either the yield type or return type could be ()
.
You can simply await
other futures, and the macro will handle that.
You can return any value you like! The caller can simply await
and get the value without iterate the stream.
This library is 7x faster than async-stream
, according to our benchmark.