Progressor

A modern, async-first progress tracking library for Rust.

Features

• Async-first: Built around Rust's async/await and Stream APIs
• Zero-allocation progress updates: Efficient progress reporting
• Flexible progress tracking: Support for current/total, messages, and cancellation
• Type-safe: Full Rust type safety with meaningful error messages
• Lightweight: Minimal dependencies and fast compilation

Usage

Add this to your Cargo.toml:

[dependencies]
progressor = "0.0.1"

Basic Example

use progressor::{Progress, updater::progress};
use futures_util::StreamExt;

#[tokio::main]
async fn main() {
    // Create a progress-tracked task
    let task = progress(100, |mut updater| async move {
        for i in 0..=100 {
            // Simulate work
            tokio::time::sleep(tokio::time::Duration::from_millis(50)).await;
            
            // Update progress
            if i % 10 == 0 {
                updater.update_with_message(i, format!("Processing step {i}/100"));
            } else {
                updater.update(i);
            }
        }
        "Task completed!"
    });

    // Monitor progress concurrently
    let mut progress_stream = Box::pin(task.progress());
    
    tokio::select! {
        result = task => {
            println!("Result: {result}");
        }
        _ = async {
            while let Some(update) = progress_stream.next().await {
                println!("Progress: {:.1}% ({}/{})", 
                         update.completed_fraction() * 100.0,
                         update.current, 
                         update.total);
                
                if update.is_complete() {
                    break;
                }
            }
        } => {}
    }
}

API Reference

ProgressUpdate

Represents a single progress update with:

• current: Current progress value
• total: Total progress value
• is_cancelled: Whether the operation was cancelled
• message: Optional progress message

Progress Trait

Trait for types that can report progress via a Stream of ProgressUpdates.

progress() Function

Creates a progress-tracked future from a closure that receives a ProgressUpdater.

License

Licensed under the MIT License. See LICENSE for details.