test: update tests/examples/benches

examples/01_basic.rs

@@ -77,13 +77,13 @@ impl Add {
 #[tokio::main]
 async fn main() {
     // Step 3: Create a new DAG
-    let dag = DagRunner::new();
+    let mut dag = DagRunner::new();
 
     // Step 4: Add source tasks (tasks with no dependencies)
     //
     // add_task() returns a TaskHandle<T> where T is the task's output type
-    let x = dag.add_task(Value::new(2)).into(); // TaskHandle<i32>
-    let y = dag.add_task(Value::new(3)).into(); // TaskHandle<i32>
+    let x = dag.add_task(Value::new(2)); // TaskHandle<i32>
+    let y = dag.add_task(Value::new(3)); // TaskHandle<i32>
 
     // Step 5: Add a task with dependencies
     //
@@ -105,7 +105,8 @@ async fn main() {
     // 1. Tasks with no dependencies run first (x and y in parallel)
     // 2. Once x and y complete, sum runs (it depends on both)
     println!("Running DAG...\n");
-    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+    let mut output = dag
+        .run(|fut| async move { tokio::spawn(fut).await.unwrap() })
         .await
         .unwrap();
 
@@ -113,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: {}", dag.get(sum).unwrap());
+    println!("\nResult: {}", output.get(sum).unwrap());
 
     // Note: You can also retrieve intermediate results
-    assert_eq!(dag.get(x).unwrap(), 2);
-    assert_eq!(dag.get(y).unwrap(), 3);
+    assert_eq!(output.get(x).unwrap(), 2);
+    assert_eq!(output.get(y).unwrap(), 3);
 }

examples/02_fan_out.rs

@@ -55,7 +55,7 @@
 //!   Squared: 100
 //! ```
 
-use dagx::{task, DagRunner, TaskHandle};
+use dagx::{task, DagRunner};
 
 // Source task with a value field
 struct Source {
@@ -127,10 +127,10 @@ impl Power {
 
 #[tokio::main]
 async fn main() {
-    let dag = DagRunner::new();
+    let mut dag = DagRunner::new();
 
     // Single source task - constructed with ::new()
-    let source: TaskHandle<_> = dag.add_task(Source::new(10)).into();
+    let source = dag.add_task(Source::new(10));
 
     // Multiple downstream tasks consuming the same value
     // Each constructed differently to show flexibility
@@ -140,14 +140,15 @@ async fn main() {
 
     // Run the DAG
     println!("Running fan-out DAG...\n");
-    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+    let mut output = dag
+        .run(|fut| async move { tokio::spawn(fut).await.unwrap() })
         .await
         .unwrap();
 
     // Print all results
     println!("\nResults:");
-    println!("  Source: {}", dag.get(source).unwrap());
-    println!("  Plus One: {}", dag.get(plus_one).unwrap());
-    println!("  Times Two: {}", dag.get(times_two).unwrap());
-    println!("  Squared: {}", dag.get(squared).unwrap());
+    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());
 }

examples/03_fan_in.rs

@@ -118,7 +118,7 @@ impl BuildProfile {
 
 #[tokio::main]
 async fn main() {
-    let dag = DagRunner::new();
+    let mut dag = DagRunner::new();
 
     // Multiple independent source tasks
     let name = dag.add_task(FetchName);
@@ -133,10 +133,11 @@ async fn main() {
 
     // Run the DAG
     println!("Running fan-in DAG...\n");
-    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+    let mut output = dag
+        .run(|fut| async move { tokio::spawn(fut).await.unwrap() })
         .await
         .unwrap();
 
     // Print result
-    println!("\n{}", dag.get(profile).unwrap());
+    println!("\n{}", output.get(profile).unwrap());
 }

examples/04_parallel_computation.rs

@@ -115,7 +115,7 @@ async fn main() -> DagResult<()> {
     println!("Running PARALLEL computation (4 workers on separate threads)...");
     let (parallel_time, parallel_result) = {
         let start = Instant::now();
-        let dag = DagRunner::new();
+        let mut dag = DagRunner::new();
 
         // Create 4 workers - dagx will run them in parallel
         let sum1 = dag.add_task(ComputeSum::new(1, 251, WORK_DELAY));
@@ -125,10 +125,11 @@ async fn main() -> DagResult<()> {
 
         let total = dag.add_task(Aggregate).depends_on((sum1, sum2, sum3, sum4));
 
-        dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+        let mut output = dag
+            .run(|fut| async move { tokio::spawn(fut).await.unwrap() })
             .await?;
 
-        let result = dag.get(total)?;
+        let result = output.get(total)?;
         let elapsed = start.elapsed();
 
         println!(

examples/circuit_breaker.rs

@@ -381,7 +381,7 @@ async fn main() {
         // Create shared circuit breaker: 3 failures trigger open, 3 second recovery timeout
         let circuit = Arc::new(CircuitBreaker::new(3, Duration::from_secs(3)));
 
-        let dag = DagRunner::new();
+        let mut dag = DagRunner::new();
 
         // Request 1: Success (circuit closed)
         let call1 = dag.add_task(ProtectedServiceCall::new(
@@ -390,56 +390,60 @@ async fn main() {
             false, // success
         ));
 
-        dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+        let mut output = dag
+            .run(|fut| async move { tokio::spawn(fut).await.unwrap() })
             .await
             .unwrap();
 
-        println!("Result 1: {:?}\n", dag.get(call1).unwrap());
+        println!("Result 1: {:?}\n", output.get(call1).unwrap());
 
         // Request 2: Failure (circuit closed, count = 1)
-        let dag = DagRunner::new();
+        let mut dag = DagRunner::new();
         let call2 = dag.add_task(ProtectedServiceCall::new(
             "ServiceCall-2",
             circuit.clone(),
             true, // fail
         ));
 
-        dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+        let mut output = dag
+            .run(|fut| async move { tokio::spawn(fut).await.unwrap() })
             .await
             .unwrap();
 
-        println!("Result 2: {:?}\n", dag.get(call2).unwrap());
+        println!("Result 2: {:?}\n", output.get(call2).unwrap());
 
         // Request 3: Failure (circuit closed, count = 2)
-        let dag = DagRunner::new();
+        let mut dag = DagRunner::new();
         let call3 = dag.add_task(ProtectedServiceCall::new(
             "ServiceCall-3",
             circuit.clone(),
             true, // fail
         ));
 
-        dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+        let mut output = dag
+            .run(|fut| async move { tokio::spawn(fut).await.unwrap() })
             .await
             .unwrap();
 
-        println!("Result 3: {:?}\n", dag.get(call3).unwrap());
+        println!("Result 3: {:?}\n", output.get(call3).unwrap());
 
         // Request 4: Failure (circuit closed, count = 3, opens!)
-        let dag = DagRunner::new();
+        let mut dag = DagRunner::new();
         let call4 = dag.add_task(ProtectedServiceCall::new(
             "ServiceCall-4",
             circuit.clone(),
             true, // fail
         ));
 
-        dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+        let mut output = dag
+            .run(|fut| async move { tokio::spawn(fut).await.unwrap() })
             .await
             .unwrap();
 
-        println!("Result 4: {:?}\n", dag.get(call4).unwrap());
+        println!("Result 4: {:?}\n", output.get(call4).unwrap());
 
         // Request 5: Circuit is now open, fails fast with fallback
-        let dag = DagRunner::new();
+        let mut dag = DagRunner::new();
         let call5 = dag.add_task(ProtectedServiceCall::new(
             "ServiceCall-5",
             circuit.clone(),
@@ -450,11 +454,12 @@ async fn main() {
             .add_task(FallbackService::new("ServiceCall-5"))
             .depends_on(call5);
 
-        dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+        let mut output = dag
+            .run(|fut| async move { tokio::spawn(fut).await.unwrap() })
             .await
             .unwrap();
 
-        println!("Result 5: {:?}\n", dag.get(fallback5).unwrap());
+        println!("Result 5: {:?}\n", output.get(fallback5).unwrap());
 
         // Example 2: Circuit recovery after timeout
         println!("Example 2: Circuit recovery after timeout\n");
@@ -462,32 +467,34 @@ async fn main() {
         sleep(Duration::from_secs(3)).await;
 
         // Request 6: Circuit should be half-open, test succeeds, closes circuit
-        let dag = DagRunner::new();
+        let mut dag = DagRunner::new();
         let call6 = dag.add_task(ProtectedServiceCall::new(
             "ServiceCall-6",
             circuit.clone(),
             false, // success
         ));
 
-        dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+        let mut output = dag
+            .run(|fut| async move { tokio::spawn(fut).await.unwrap() })
             .await
             .unwrap();
 
-        println!("Result 6: {:?}\n", dag.get(call6).unwrap());
+        println!("Result 6: {:?}\n", output.get(call6).unwrap());
 
         // Request 7: Circuit is now closed again, normal operation
-        let dag = DagRunner::new();
+        let mut dag = DagRunner::new();
         let call7 = dag.add_task(ProtectedServiceCall::new(
             "ServiceCall-7",
             circuit.clone(),
             false, // success
         ));
 
-        dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+        let mut output = dag
+            .run(|fut| async move { tokio::spawn(fut).await.unwrap() })
             .await
             .unwrap();
 
-        println!("Result 7: {:?}\n", dag.get(call7).unwrap());
+        println!("Result 7: {:?}\n", output.get(call7).unwrap());
     }
 
     println!("=== Circuit Breaker Example Complete ===");

examples/data_pipeline.rs

@@ -178,7 +178,7 @@ impl GenerateReport {
 
 #[tokio::main]
 async fn main() {
-    let dag = DagRunner::new();
+    let mut dag = DagRunner::new();
 
     println!("Building data pipeline DAG...\n");
 
@@ -220,10 +220,11 @@ async fn main() {
 
     // Execute the pipeline
     println!("Executing pipeline...\n");
-    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+    let mut output = dag
+        .run(|fut| async move { tokio::spawn(fut).await.unwrap() })
         .await
         .unwrap();
 
     // Print final report
-    println!("{}", dag.get(report).unwrap());
+    println!("{}", output.get(report).unwrap());
 }

examples/error_handling.rs

@@ -209,7 +209,7 @@ async fn main() {
     // Example 1: Successful path
     println!("Example 1: Valid input");
     {
-        let dag = DagRunner::new();
+        let mut dag = DagRunner::new();
 
         let input = dag.add_task(StringSource("42"));
 
@@ -222,11 +222,12 @@ async fn main() {
         let processed = dag.add_task(ProcessData).depends_on(validated);
         let logged = dag.add_task(LogError).depends_on(processed);
 
-        dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+        let mut output = dag
+            .run(|fut| async move { tokio::spawn(fut).await.unwrap() })
             .await
             .unwrap();
 
-        match dag.get(logged).unwrap().as_ref() {
+        match output.get(logged).unwrap().as_ref() {
             Ok(result) => println!("Final result: {}\n", result),
             Err(e) => eprintln!("Final error: {}\n", e),
         }
@@ -235,7 +236,7 @@ async fn main() {
     // Example 2: Parse error
     println!("Example 2: Invalid input (parse error)");
     {
-        let dag = DagRunner::new();
+        let mut dag = DagRunner::new();
 
         let input = dag.add_task(StringSource("not a number"));
 
@@ -248,11 +249,12 @@ async fn main() {
         let processed = dag.add_task(ProcessData).depends_on(validated);
         let logged = dag.add_task(LogError).depends_on(processed);
 
-        dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+        let mut output = dag
+            .run(|fut| async move { tokio::spawn(fut).await.unwrap() })
             .await
             .unwrap();
 
-        match dag.get(logged).unwrap().as_ref() {
+        match output.get(logged).unwrap().as_ref() {
             Ok(result) => println!("Final result: {}\n", result),
             Err(e) => eprintln!("Final error: {}\n", e),
         }
@@ -261,7 +263,7 @@ async fn main() {
     // Example 3: Validation error
     println!("Example 3: Out of range");
     {
-        let dag = DagRunner::new();
+        let mut dag = DagRunner::new();
 
         let input = dag.add_task(StringSource("150"));
 
@@ -274,11 +276,12 @@ async fn main() {
         let processed = dag.add_task(ProcessData).depends_on(validated);
         let logged = dag.add_task(LogError).depends_on(processed);
 
-        dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+        let mut output = dag
+            .run(|fut| async move { tokio::spawn(fut).await.unwrap() })
             .await
             .unwrap();
 
-        match dag.get(logged).unwrap().as_ref() {
+        match output.get(logged).unwrap().as_ref() {
             Ok(result) => println!("Final result: {}\n", result),
             Err(e) => eprintln!("Final error: {}\n", e),
         }
@@ -287,7 +290,7 @@ async fn main() {
     // Example 4: Error recovery with fallback
     println!("Example 4: Error recovery with fallback");
     {
-        let dag = DagRunner::new();
+        let mut dag = DagRunner::new();
 
         let input = dag.add_task(StringSource("invalid"));
 
@@ -297,11 +300,12 @@ async fn main() {
             .add_task(WithFallback { fallback: 0 })
             .depends_on(parsed);
 
-        dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+        let mut output = dag
+            .run(|fut| async move { tokio::spawn(fut).await.unwrap() })
             .await
             .unwrap();
 
-        let result = dag.get(with_fallback).unwrap();
+        let result = output.get(with_fallback).unwrap();
         println!("Recovered with fallback: {}\n", result);
     }