trale 0.3.0

Trale is a minimalistic Rust async executor using io_uring for efficient, correct task execution.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

use std::time::Duration;

use anyhow::{Context, Result};
use trale::{
    futures::{read::AsyncRead, tcp::TcpStream, timer::Timer, write::AsyncWrite},
    task::{Executor, TaskJoiner},
};

fn main() -> Result<()> {
    Executor::spawn(async {
        Timer::sleep(Duration::from_millis(500)).unwrap().await;
        println!("Hello A!");
        Timer::sleep(Duration::from_secs(1)).unwrap().await;
        println!("Hello B!");
        Timer::sleep(Duration::from_secs(1)).unwrap().await;
        println!("Hello C!");
    });

    let echo_task: TaskJoiner<Result<usize>> = Executor::spawn(async {
        let mut buf = [0u8; 1];
        let mut bytes_read: usize = 0;
        let mut sock = TcpStream::connect("127.0.0.1:5000")
            .await
            .context("Could not connect")?;
        loop {
            let len = sock.read(&mut buf).await?;
            if len == 0 {
                return Ok(bytes_read);
            }
            bytes_read += 1;
            sock.write(&buf).await?;
        }
    });

    Executor::run();

    let bytes_read = echo_task.join()?;
    eprintln!("Conversation finished.  Read {bytes_read} bytes");

    Ok(())
}