#stream #async-stream #future #iterator #coroutine #yield #nightly

nightly no-std stream-future

Implement an async iterator with return value

7 unstable releases

0.4.1 Oct 24, 2023
0.4.0 Mar 21, 2023
0.3.1 Dec 24, 2022
0.3.0 Aug 31, 2022
0.1.1 Aug 26, 2022

#1436 in Asynchronous

Download history 21/week @ 2023-12-05 32/week @ 2023-12-12 153/week @ 2023-12-19 14/week @ 2023-12-26 12/week @ 2024-01-02 11/week @ 2024-01-09 8/week @ 2024-01-16 12/week @ 2024-01-30 15/week @ 2024-02-06 23/week @ 2024-02-13 40/week @ 2024-02-20 34/week @ 2024-02-27 19/week @ 2024-03-05 27/week @ 2024-03-12 32/week @ 2024-03-19

136 downloads per month
Used in 2 crates

MIT license

12KB
151 lines

stream-future

crates.io docs.rs

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.

Compare with async-stream

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.

Dependencies

~0.4–0.8MB
~19K SLoC