when2task 0.3.1

high-performance library for executing async tasks with automatic dependency resolution and optimal parallelization.
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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

# when2task

A lightweight, dependency-aware task execution library for Rust that allows you to define tasks with dependencies and execute them in the correct order.

## Features

- **Dependency Management**: Define tasks with dependencies on other tasks
- **Automatic Scheduling**: Tasks are automatically executed in dependency order
- **Concurrent Execution**: Independent tasks run concurrently within each execution step
- **Flexible Execution Modes**: Choose between true async or pseudo async execution
- **Type Safety**: Full generic support for task results and errors

## Example

```rust
use std::time::{Duration, Instant};
use when2task::{Dependency, ExecutionMode, Task, TaskExecutor, TaskExecutorBuilder};

#[tokio::main]
async fn main() {
    let start = Instant::now();

    // Independent tasks that run concurrently
    let task_a = Task::new_independent(async {
        tokio::time::sleep(Duration::from_millis(100)).await;
        println!("Task A completed after 100ms");
        Ok::<&str, ()>("A")
    });

    let task_b = Task::new_independent(async {
        tokio::time::sleep(Duration::from_millis(150)).await;
        println!("Task B completed after 150ms");
        Ok::<&str, ()>("B")
    });

    let task_a_id = *task_a.id();
    let task_b_id = *task_b.id();

    // Dependent task that waits for both A and B
    let task_c = Task::new(
        async {
            tokio::time::sleep(Duration::from_millis(50)).await;
            println!("Task C completed after both A and B (50ms additional)");
            Ok::<&str, ()>("C")
        },
        Dependency::from([task_a_id, task_b_id]),
    );

    let builder = TaskExecutorBuilder::new(ExecutionMode::true_async());

    builder.insert(task_a).insert(task_b).insert(task_c);
    let executor = builder.build().unwrap();

    let result = executor.execute().await.unwrap();

    println!("Total execution time: {:?}", start.elapsed());
    println!("Tasks completed in {} steps", result.steps.len());
    // Output shows ~200ms total (150ms for step 1 + 50ms for step 2)
    // demonstrating concurrent execution of A & B, then C
}
```

## Core Concepts

- **Task**: A unit of work represented as a future that returns `Result<T, E>`
- **Dependency**: Specifies which tasks must complete before a task can run
- **TaskExecutor**: Manages and executes tasks in dependency order
- **ExecutionMode**: Determines how tasks are scheduled (direct execution vs spawned)
- **ExecutionResult**: Contains the results of all executed tasks organized by execution steps

## License

This project is licensed under the MIT License - see the LICENSE file for details.