swaits/dagx
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix: change where TaskHandle is borrowed to prevent repeat output fetches

Browse Source
This commit is contained in:
TechnoPorg committed 2026-02-20 19:00:18 +01:00
1 parent c8efb00175
commit 9fbe4c2fd8
47 files changed
+323 -513
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

examples/01_basic.rs
+5 -5
View File
@@ -93,8 +93,8 @@ async fn main() {
.add_task(Add {
label: "Sum".to_string(),
})
.depends_on((x, y)); // Pass handles as a tuple
// sum is now TaskHandle<i32>
.depends_on((&x, &y)); // Pass handles as a tuple
// sum is now TaskHandle<i32>
// Step 6: Execute the DAG
//
@@ -114,9 +114,9 @@ async fn main() {
//
// Use .get() with a TaskHandle to retrieve the output.
// Results are not cloned, so you can only retrieve them once.
println!("\nResult: {}", output.get(sum).unwrap());
println!("\nResult: {}", output.get(sum));
// Note: You can also retrieve intermediate results
assert_eq!(output.get(x).unwrap(), 2);
assert_eq!(output.get(y).unwrap(), 3);
assert_eq!(output.get(x), 2);
assert_eq!(output.get(y), 3);
}
examples/02_fan_out.rs
+7 -7
View File
@@ -134,9 +134,9 @@ async fn main() {
// Multiple downstream tasks consuming the same value
// Each constructed differently to show flexibility
let plus_one = dag.add_task(AddOffset::new(1)).depends_on(source);
let times_two = dag.add_task(Multiply::new(2)).depends_on(source);
let squared = dag.add_task(Power { exponent: 2 }).depends_on(source);
let plus_one = dag.add_task(AddOffset::new(1)).depends_on(&source);
let times_two = dag.add_task(Multiply::new(2)).depends_on(&source);
let squared = dag.add_task(Power { exponent: 2 }).depends_on(&source);
// Run the DAG
println!("Running fan-out DAG...\n");
@@ -147,8 +147,8 @@ async fn main() {
// Print all results
println!("\nResults:");
println!(" Source: {}", output.get(source).unwrap());
println!(" Plus One: {}", output.get(plus_one).unwrap());
println!(" Times Two: {}", output.get(times_two).unwrap());
println!(" Squared: {}", output.get(squared).unwrap());
println!(" Source: {}", output.get(source));
println!(" Plus One: {}", output.get(plus_one));
println!(" Times Two: {}", output.get(times_two));
println!(" Squared: {}", output.get(squared));
}
examples/03_fan_in.rs
+3 -3
View File
@@ -29,7 +29,7 @@
//! ## Key Concepts
//! - **Fan-in**: Multiple tasks' outputs are consumed by a single downstream task
//! - **Aggregation**: Combining multiple values into a single result
//! - **Parameter order**: The order in `.depends_on((a, b, c))` must match
//! - **Parameter order**: The order in `.depends_on((&a, &b, &c))` must match
//! the function signature `fn run(a: &T1, b: &T2, c: &T3)`
//!
//! ## Use Cases
@@ -129,7 +129,7 @@ async fn main() {
// Single downstream task consuming all values
let profile = dag
.add_task(BuildProfile)
.depends_on((name, age, city, active));
.depends_on((&name, &age, &city, &active));
// Run the DAG
println!("Running fan-in DAG...\n");
@@ -139,5 +139,5 @@ async fn main() {
.unwrap();
// Print result
println!("\n{}", output.get(profile).unwrap());
println!("\n{}", output.get(profile));
}
examples/04_parallel_computation.rs
+4 -2
View File
@@ -123,13 +123,15 @@ async fn main() -> DagResult<()> {
let sum3 = dag.add_task(ComputeSum::new(501, 751, WORK_DELAY));
let sum4 = dag.add_task(ComputeSum::new(751, 1001, WORK_DELAY));
let total = dag.add_task(Aggregate).depends_on((sum1, sum2, sum3, sum4));
let total = dag
.add_task(Aggregate)
.depends_on((&sum1, &sum2, &sum3, &sum4));
let mut output = dag
.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
.await?;
let result = output.get(total)?;
let result = output.get(total);
let elapsed = start.elapsed();
println!(
examples/circuit_breaker.rs
+8 -8
View File
@@ -395,7 +395,7 @@ async fn main() {
.await
.unwrap();
println!("Result 1: {:?}\n", output.get(call1).unwrap());
println!("Result 1: {:?}\n", output.get(call1));
// Request 2: Failure (circuit closed, count = 1)
let mut dag = DagRunner::new();
@@ -410,7 +410,7 @@ async fn main() {
.await
.unwrap();
println!("Result 2: {:?}\n", output.get(call2).unwrap());
println!("Result 2: {:?}\n", output.get(call2));
// Request 3: Failure (circuit closed, count = 2)
let mut dag = DagRunner::new();
@@ -425,7 +425,7 @@ async fn main() {
.await
.unwrap();
println!("Result 3: {:?}\n", output.get(call3).unwrap());
println!("Result 3: {:?}\n", output.get(call3));
// Request 4: Failure (circuit closed, count = 3, opens!)
let mut dag = DagRunner::new();
@@ -440,7 +440,7 @@ async fn main() {
.await
.unwrap();
println!("Result 4: {:?}\n", output.get(call4).unwrap());
println!("Result 4: {:?}\n", output.get(call4));
// Request 5: Circuit is now open, fails fast with fallback
let mut dag = DagRunner::new();
@@ -452,14 +452,14 @@ async fn main() {
let fallback5 = dag
.add_task(FallbackService::new("ServiceCall-5"))
.depends_on(call5);
.depends_on(&call5);
let mut output = dag
.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
.await
.unwrap();
println!("Result 5: {:?}\n", output.get(fallback5).unwrap());
println!("Result 5: {:?}\n", output.get(fallback5));
// Example 2: Circuit recovery after timeout
println!("Example 2: Circuit recovery after timeout\n");
@@ -479,7 +479,7 @@ async fn main() {
.await
.unwrap();
println!("Result 6: {:?}\n", output.get(call6).unwrap());
println!("Result 6: {:?}\n", output.get(call6));
// Request 7: Circuit is now closed again, normal operation
let mut dag = DagRunner::new();
@@ -494,7 +494,7 @@ async fn main() {
.await
.unwrap();
println!("Result 7: {:?}\n", output.get(call7).unwrap());
println!("Result 7: {:?}\n", output.get(call7));
}
println!("=== Circuit Breaker Example Complete ===");
examples/data_pipeline.rs
+10 -8
View File
@@ -190,31 +190,33 @@ async fn main() {
// Stage 2: Data transformation (with stateful tasks)
let transformed_1 = dag
.add_task(DataTransformer::new(1.5))
.depends_on(raw_value_1);
.depends_on(&raw_value_1);
let transformed_2 = dag
.add_task(DataTransformer::new(2.0))
.depends_on(raw_value_2);
.depends_on(&raw_value_2);
let transformed_3 = dag
.add_task(DataTransformer::new(0.5))
.depends_on(raw_value_3);
.depends_on(&raw_value_3);
// Stage 3: Statistical analysis (parallel operations on transformed data)
let sum = dag
.add_task(ComputeSum)
.depends_on((transformed_1, transformed_2, transformed_3));
.depends_on((&transformed_1, &transformed_2, &transformed_3));
let product =
dag.add_task(ComputeProduct)
.depends_on((transformed_1, transformed_2, transformed_3));
.depends_on((&transformed_1, &transformed_2, &transformed_3));
let max = dag
.add_task(FindMax)
.depends_on((transformed_1, transformed_2, transformed_3));
.depends_on((&transformed_1, &transformed_2, &transformed_3));
// Stage 4: Final report
let report = dag.add_task(GenerateReport).depends_on((sum, product, max));
let report = dag
.add_task(GenerateReport)
.depends_on((&sum, &product, &max));
// Execute the pipeline
println!("Executing pipeline...\n");
@@ -224,5 +226,5 @@ async fn main() {
.unwrap();
// Print final report
println!("{}", output.get(report).unwrap());
println!("{}", output.get(report));
}
examples/error_handling.rs
+18 -18
View File
@@ -213,21 +213,21 @@ async fn main() {
let input = dag.add_task(StringSource("42"));
let parsed = dag.add_task(ParseInt).depends_on(input);
let parsed = dag.add_task(ParseInt).depends_on(&input);
let validated = dag
.add_task(ValidateRange { min: 0, max: 100 })
.depends_on(parsed);
.depends_on(&parsed);
let processed = dag.add_task(ProcessData).depends_on(validated);
let logged = dag.add_task(LogError).depends_on(processed);
let processed = dag.add_task(ProcessData).depends_on(&validated);
let logged = dag.add_task(LogError).depends_on(&processed);
let mut output = dag
.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
.await
.unwrap();
match output.get(logged).unwrap().as_ref() {
match output.get(logged).as_ref() {
Ok(result) => println!("Final result: {}\n", result),
Err(e) => eprintln!("Final error: {}\n", e),
}
@@ -240,21 +240,21 @@ async fn main() {
let input = dag.add_task(StringSource("not a number"));
let parsed = dag.add_task(ParseInt).depends_on(input);
let parsed = dag.add_task(ParseInt).depends_on(&input);
let validated = dag
.add_task(ValidateRange { min: 0, max: 100 })
.depends_on(parsed);
.depends_on(&parsed);
let processed = dag.add_task(ProcessData).depends_on(validated);
let logged = dag.add_task(LogError).depends_on(processed);
let processed = dag.add_task(ProcessData).depends_on(&validated);
let logged = dag.add_task(LogError).depends_on(&processed);
let mut output = dag
.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
.await
.unwrap();
match output.get(logged).unwrap().as_ref() {
match output.get(logged).as_ref() {
Ok(result) => println!("Final result: {}\n", result),
Err(e) => eprintln!("Final error: {}\n", e),
}
@@ -267,21 +267,21 @@ async fn main() {
let input = dag.add_task(StringSource("150"));
let parsed = dag.add_task(ParseInt).depends_on(input);
let parsed = dag.add_task(ParseInt).depends_on(&input);
let validated = dag
.add_task(ValidateRange { min: 0, max: 100 })
.depends_on(parsed);
.depends_on(&parsed);
let processed = dag.add_task(ProcessData).depends_on(validated);
let logged = dag.add_task(LogError).depends_on(processed);
let processed = dag.add_task(ProcessData).depends_on(&validated);
let logged = dag.add_task(LogError).depends_on(&processed);
let mut output = dag
.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
.await
.unwrap();
match output.get(logged).unwrap().as_ref() {
match output.get(logged).as_ref() {
Ok(result) => println!("Final result: {}\n", result),
Err(e) => eprintln!("Final error: {}\n", e),
}
@@ -294,18 +294,18 @@ async fn main() {
let input = dag.add_task(StringSource("invalid"));
let parsed = dag.add_task(ParseInt).depends_on(input);
let parsed = dag.add_task(ParseInt).depends_on(&input);
let with_fallback = dag
.add_task(WithFallback { fallback: 0 })
.depends_on(parsed);
.depends_on(&parsed);
let mut output = dag
.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
.await
.unwrap();
let result = output.get(with_fallback).unwrap();
let result = output.get(with_fallback);
println!("Recovered with fallback: {}\n", result);
}