io-stream

Crates.io	io-stream
lib.rs	io-stream
version	0.0.2
created_at	2025-06-04 08:54:49.509696+00
updated_at	2025-08-03 07:26:41.332403+00
description	Set of I/O-free coroutines and runtimes to manage streams
homepage	https://pimalaya.org
repository	https://github.com/pimalaya/io-stream
max_upload_size
id	1699978
size	97,749

Clément DOUIN (soywod)

documentation

https://docs.rs/io-stream/latest/io_stream

README

I/O Stream

Set of I/O-free Rust coroutines and runtimes to manage streams.

This library allows you to manage streams using an I/O-agnostic approach, based on 3 concepts:

Coroutine

A coroutine is an I/O-free, resumable and composable state machine that emits I/O requests. A coroutine is considered terminated when it does not emit I/O requests anymore.

See available coroutines at ./src/coroutines.

Runtime

A runtime contains all the I/O logic, and is responsible for processing I/O requests emitted by coroutines.

See available runtimes at ./src/runtimes.

Loop

The loop is the glue between coroutines and runtimes. It makes the coroutine progress while allowing runtime to process I/O.

Examples

Read stdin synchronously

use io_stream::{coroutines::Read, runtimes::std::handle};

let mut stdin = std::io::stdin();

let mut arg = None;
let mut read = Read::new();

let output = loop {
    match read.resume(arg) {
        Ok(output) => break output,
        Err(io) => arg = Some(handle(&mut stdin, io).unwrap()),
    }
};

// same as &output.buffer[..output.bytes_count]
let bytes = output.bytes();

Write TCP stream asynchronously

use tokio::net::TcpStream;
use io_stream::{coroutines::Write, runtimes::tokio::handle};

let mut tcp = TcpStream::connect("127.0.0.1:1234").await.unwrap();

let mut arg = None;
let mut write = Write::new(b"bytes".iter().cloned());

while let Err(io) = write.resume(arg) {
    arg = Some(handle(&mut tcp, io).await.unwrap());
}

See complete examples at ./examples.