Update tests, examples, benches

examples/01_basic.rs

@@ -31,6 +31,7 @@
 //! ```
 
 use dagx::{task, DagRunner, Task};
+use futures::FutureExt;
 
 // Step 1: Define a source task (no dependencies)
 //
@@ -105,11 +106,9 @@ 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| {
-        tokio::spawn(fut);
-    })
-    .await
-    .unwrap();
+    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+        .await
+        .unwrap();
 
     // Step 7: Retrieve results
     //

examples/02_fan_out.rs

@@ -56,6 +56,7 @@
 //! ```
 
 use dagx::{task, DagRunner, Task};
+use futures::FutureExt;
 
 // Source task with a value field
 struct Source {
@@ -140,11 +141,9 @@ async fn main() {
 
     // Run the DAG
     println!("Running fan-out DAG...\n");
-    dag.run(|fut| {
-        tokio::spawn(fut);
-    })
-    .await
-    .unwrap();
+    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+        .await
+        .unwrap();
 
     // Print all results
     println!("\nResults:");

examples/03_fan_in.rs

@@ -62,6 +62,7 @@
 //! ```
 
 use dagx::{task, DagRunner, Task};
+use futures::FutureExt;
 
 struct FetchName;
 
@@ -133,11 +134,9 @@ async fn main() {
 
     // Run the DAG
     println!("Running fan-in DAG...\n");
-    dag.run(|fut| {
-        tokio::spawn(fut);
-    })
-    .await
-    .unwrap();
+    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+        .await
+        .unwrap();
 
     // Print result
     println!("\n{}", dag.get(profile).unwrap());

examples/04_parallel_computation.rs

@@ -53,6 +53,7 @@
 //! ```
 
 use dagx::{task, DagResult, DagRunner, Task};
+use futures::FutureExt;
 use std::time::{Duration, Instant};
 use tokio::time::sleep;
 
@@ -126,10 +127,7 @@ async fn main() -> DagResult<()> {
             .add_task(Aggregate)
             .depends_on((&sum1, &sum2, &sum3, &sum4));
 
-        dag.run(|fut| {
-            tokio::spawn(fut);
-        })
-        .await?;
+        dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
 
         let result = dag.get(total)?;
         let elapsed = start.elapsed();

examples/circuit_breaker.rs

@@ -151,6 +151,7 @@
 //! ```
 
 use dagx::{task, DagRunner, Task};
+use futures::FutureExt;
 use std::sync::Arc;
 use std::time::Instant;
 use tokio::sync::Mutex;
@@ -389,11 +390,9 @@ async fn main() {
             false, // success
         ));
 
-        dag.run(|fut| {
-            tokio::spawn(fut);
-        })
-        .await
-        .unwrap();
+        dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+            .await
+            .unwrap();
 
         println!("Result 1: {:?}\n", dag.get(call1).unwrap());
 
@@ -405,11 +404,9 @@ async fn main() {
             true, // fail
         ));
 
-        dag.run(|fut| {
-            tokio::spawn(fut);
-        })
-        .await
-        .unwrap();
+        dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+            .await
+            .unwrap();
 
         println!("Result 2: {:?}\n", dag.get(call2).unwrap());
 
@@ -421,11 +418,9 @@ async fn main() {
             true, // fail
         ));
 
-        dag.run(|fut| {
-            tokio::spawn(fut);
-        })
-        .await
-        .unwrap();
+        dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+            .await
+            .unwrap();
 
         println!("Result 3: {:?}\n", dag.get(call3).unwrap());
 
@@ -437,11 +432,9 @@ async fn main() {
             true, // fail
         ));
 
-        dag.run(|fut| {
-            tokio::spawn(fut);
-        })
-        .await
-        .unwrap();
+        dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+            .await
+            .unwrap();
 
         println!("Result 4: {:?}\n", dag.get(call4).unwrap());
 
@@ -457,11 +450,9 @@ async fn main() {
             .add_task(FallbackService::new("ServiceCall-5"))
             .depends_on(&call5);
 
-        dag.run(|fut| {
-            tokio::spawn(fut);
-        })
-        .await
-        .unwrap();
+        dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+            .await
+            .unwrap();
 
         println!("Result 5: {:?}\n", dag.get(fallback5).unwrap());
 
@@ -478,11 +469,9 @@ async fn main() {
             false, // success
         ));
 
-        dag.run(|fut| {
-            tokio::spawn(fut);
-        })
-        .await
-        .unwrap();
+        dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+            .await
+            .unwrap();
 
         println!("Result 6: {:?}\n", dag.get(call6).unwrap());
 
@@ -494,11 +483,9 @@ async fn main() {
             false, // success
         ));
 
-        dag.run(|fut| {
-            tokio::spawn(fut);
-        })
-        .await
-        .unwrap();
+        dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+            .await
+            .unwrap();
 
         println!("Result 7: {:?}\n", dag.get(call7).unwrap());
     }

examples/complex_dag.rs

@@ -67,6 +67,7 @@
 //! ```
 
 use dagx::{task, DagResult, DagRunner, Task};
+use futures::FutureExt;
 
 // Extract: Load data from different sources
 struct LoadData {
@@ -201,10 +202,7 @@ async fn main() -> DagResult<()> {
 
     // Execute the entire ETL pipeline
     println!("Executing pipeline...\n");
-    dag.run(|fut| {
-        tokio::spawn(fut);
-    })
-    .await?;
+    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
 
     // Display final report
     println!("\n{}", dag.get(report)?);

examples/conditional_workflow.rs

@@ -56,6 +56,7 @@
 //! ```
 
 use dagx::{task, DagResult, DagRunner, Task};
+use futures::FutureExt;
 
 // Task that validates and processes input
 struct ValidateAndDouble {
@@ -137,10 +138,7 @@ async fn main() -> DagResult<()> {
         .depends_on((&cat1, &cat2, &cat3));
 
     // Execute
-    dag.run(|fut| {
-        tokio::spawn(fut);
-    })
-    .await?;
+    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
 
     // Display results
     println!("\nFinal summary: {}", dag.get(summary)?);

examples/custom_types.rs

@@ -37,6 +37,7 @@
 //! ```
 
 use dagx::{task, DagRunner, Task};
+use futures::FutureExt;
 
 // Custom type - just derive Clone!
 #[derive(Clone, Debug)]
@@ -107,11 +108,9 @@ async fn main() {
     let validation = dag.add_task(ValidateUser).depends_on(&user_task);
 
     // Execute the DAG
-    dag.run(|fut| {
-        tokio::spawn(fut);
-    })
-    .await
-    .unwrap();
+    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+        .await
+        .unwrap();
 
     // Print results
     println!("Greeting: {}", dag.get(greeting).unwrap());

examples/data_pipeline.rs

@@ -76,6 +76,7 @@
 //! ```
 
 use dagx::{task, DagRunner, Task};
+use futures::FutureExt;
 
 // Data source tasks
 struct LoadValue1;
@@ -220,11 +221,9 @@ async fn main() {
 
     // Execute the pipeline
     println!("Executing pipeline...\n");
-    dag.run(|fut| {
-        tokio::spawn(fut);
-    })
-    .await
-    .unwrap();
+    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+        .await
+        .unwrap();
 
     // Print final report
     println!("{}", dag.get(report).unwrap());

examples/debug_tracing.rs

@@ -115,6 +115,7 @@
 //! ```
 
 use dagx::{task, DagRunner, Task};
+use futures::FutureExt;
 use std::time::Instant;
 use tokio::time::{sleep, Duration};
 
@@ -400,11 +401,9 @@ async fn main() {
             .depends_on((&inventory, &payment, &shipping));
 
         // Run the DAG
-        dag.run(|fut| {
-            tokio::spawn(fut);
-        })
-        .await
-        .unwrap();
+        dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+            .await
+            .unwrap();
 
         // Print summary
         dag.get(summary).unwrap().print();
@@ -442,11 +441,9 @@ async fn main() {
             true, // will fail
         ));
 
-        dag.run(|fut| {
-            tokio::spawn(fut);
-        })
-        .await
-        .unwrap();
+        dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+            .await
+            .unwrap();
 
         // Check results
         match dag.get(payment).unwrap() {

examples/error_handling.rs

@@ -115,6 +115,7 @@
 //! ```
 
 use dagx::{task, DagRunner, Task};
+use futures::FutureExt;
 
 // Source task that provides a string input
 struct StringSource(&'static str);
@@ -222,11 +223,9 @@ async fn main() {
         let processed = dag.add_task(ProcessData).depends_on(validated);
         let logged = dag.add_task(LogError).depends_on(processed);
 
-        dag.run(|fut| {
-            tokio::spawn(fut);
-        })
-        .await
-        .unwrap();
+        dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+            .await
+            .unwrap();
 
         match dag.get(logged).unwrap() {
             Ok(result) => println!("Final result: {}\n", result),
@@ -250,11 +249,9 @@ async fn main() {
         let processed = dag.add_task(ProcessData).depends_on(validated);
         let logged = dag.add_task(LogError).depends_on(processed);
 
-        dag.run(|fut| {
-            tokio::spawn(fut);
-        })
-        .await
-        .unwrap();
+        dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+            .await
+            .unwrap();
 
         match dag.get(logged).unwrap() {
             Ok(result) => println!("Final result: {}\n", result),
@@ -278,11 +275,9 @@ async fn main() {
         let processed = dag.add_task(ProcessData).depends_on(validated);
         let logged = dag.add_task(LogError).depends_on(processed);
 
-        dag.run(|fut| {
-            tokio::spawn(fut);
-        })
-        .await
-        .unwrap();
+        dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+            .await
+            .unwrap();
 
         match dag.get(logged).unwrap() {
             Ok(result) => println!("Final result: {}\n", result),
@@ -303,11 +298,9 @@ async fn main() {
             .add_task(WithFallback { fallback: 0 })
             .depends_on(parsed);
 
-        dag.run(|fut| {
-            tokio::spawn(fut);
-        })
-        .await
-        .unwrap();
+        dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+            .await
+            .unwrap();
 
         let result = dag.get(with_fallback).unwrap();
         println!("Recovered with fallback: {}\n", result);

examples/large_dag.rs

@@ -110,6 +110,7 @@
 //! ```
 
 use dagx::{task, DagRunner, Task};
+use futures::FutureExt;
 use std::time::Instant;
 
 // Simple computation task
@@ -181,11 +182,9 @@ async fn main() {
         println!("  Build time: {:?}", build_time);
 
         let exec_start = Instant::now();
-        dag.run(|fut| {
-            tokio::spawn(fut);
-        })
-        .await
-        .unwrap();
+        dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+            .await
+            .unwrap();
         let exec_time = exec_start.elapsed();
 
         println!("  Execution time: {:?}", exec_time);
@@ -223,11 +222,9 @@ async fn main() {
         println!("  Build time: {:?}", build_time);
 
         let exec_start = Instant::now();
-        dag.run(|fut| {
-            tokio::spawn(fut);
-        })
-        .await
-        .unwrap();
+        dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+            .await
+            .unwrap();
         let exec_time = exec_start.elapsed();
 
         println!("  Execution time: {:?}", exec_time);
@@ -276,11 +273,9 @@ async fn main() {
         println!("  Tree depth: {}", level);
 
         let exec_start = Instant::now();
-        dag.run(|fut| {
-            tokio::spawn(fut);
-        })
-        .await
-        .unwrap();
+        dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+            .await
+            .unwrap();
         let exec_time = exec_start.elapsed();
 
         println!("  Execution time: {:?}", exec_time);
@@ -336,11 +331,9 @@ async fn main() {
         println!("  Build time: {:?}", build_time);
 
         let exec_start = Instant::now();
-        dag.run(|fut| {
-            tokio::spawn(fut);
-        })
-        .await
-        .unwrap();
+        dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+            .await
+            .unwrap();
         let exec_time = exec_start.elapsed();
 
         println!("  Execution time: {:?}", exec_time);
@@ -362,11 +355,9 @@ async fn main() {
             .map(|i| dag.add_task(FormatNumber { id: i }))
             .collect();
 
-        dag.run(|fut| {
-            tokio::spawn(fut);
-        })
-        .await
-        .unwrap();
+        dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+            .await
+            .unwrap();
 
         // Verify results are accessible
         let i32_sum: i32 = small_tasks

examples/parallelism_proof.rs

@@ -48,6 +48,7 @@
 //! ```
 
 use dagx::{task, DagRunner, Task};
+use futures::FutureExt;
 use std::time::{Duration, Instant};
 use tokio::time::sleep;
 
@@ -86,11 +87,9 @@ async fn main() {
 
     // Measure execution time
     let start = Instant::now();
-    dag.run(|fut| {
-        tokio::spawn(fut);
-    })
-    .await
-    .unwrap();
+    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+        .await
+        .unwrap();
     let elapsed = start.elapsed();
 
     // Verify all tasks completed correctly

examples/retry_strategies.rs

@@ -153,6 +153,7 @@
 //! ```
 
 use dagx::{task, DagRunner, Task};
+use futures::FutureExt;
 use tokio::time::{sleep, Duration};
 
 // Retry strategy configuration
@@ -355,11 +356,9 @@ async fn main() {
             ],
         ));
 
-        dag.run(|fut| {
-            tokio::spawn(fut);
-        })
-        .await
-        .unwrap();
+        dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+            .await
+            .unwrap();
 
         println!("Result: {:?}\n", dag.get(api_call).unwrap());
     }
@@ -379,11 +378,9 @@ async fn main() {
             ],
         ));
 
-        dag.run(|fut| {
-            tokio::spawn(fut);
-        })
-        .await
-        .unwrap();
+        dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+            .await
+            .unwrap();
 
         println!("Result: {:?}\n", dag.get(api_call).unwrap());
     }
@@ -407,11 +404,9 @@ async fn main() {
             ],
         ));
 
-        dag.run(|fut| {
-            tokio::spawn(fut);
-        })
-        .await
-        .unwrap();
+        dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+            .await
+            .unwrap();
 
         println!("Result: {:?}\n", dag.get(api_call).unwrap());
     }
@@ -428,11 +423,9 @@ async fn main() {
             vec![ApiError::AuthenticationFailed],
         ));
 
-        dag.run(|fut| {
-            tokio::spawn(fut);
-        })
-        .await
-        .unwrap();
+        dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+            .await
+            .unwrap();
 
         println!("Result: {:?}\n", dag.get(api_call).unwrap());
     }
@@ -457,11 +450,9 @@ async fn main() {
             ],
         ));
 
-        dag.run(|fut| {
-            tokio::spawn(fut);
-        })
-        .await
-        .unwrap();
+        dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+            .await
+            .unwrap();
 
         println!("Result: {:?}\n", dag.get(api_call).unwrap());
     }

examples/timeout.rs

@@ -24,7 +24,7 @@
 //!
 //! **2. DAG-Level Timeout** - Entire workflow with timeout
 //! ```rust
-//! match timeout(dag_timeout, dag.run(spawner)).await {
+//! match timeout(dag_timeout, dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await {
 //!     Ok(result) => { /* DAG completed */ },
 //!     Err(_) => { /* DAG timed out */ },
 //! }
@@ -99,6 +99,7 @@
 //! ```
 
 use dagx::{task, DagRunner, Task};
+use futures::FutureExt;
 use tokio::time::{sleep, timeout, Duration};
 
 // Fast task that completes quickly
@@ -177,11 +178,9 @@ async fn main() {
             timeout_ms: 500,
         });
 
-        dag.run(|fut| {
-            tokio::spawn(fut);
-        })
-        .await
-        .unwrap();
+        dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+            .await
+            .unwrap();
 
         println!("Fast task: {:?}", dag.get(fast).unwrap());
         println!("Timed task: {:?}\n", dag.get(timed).unwrap());
@@ -199,11 +198,9 @@ async fn main() {
 
         let processed = dag.add_task(ProcessResult).depends_on(&timed);
 
-        dag.run(|fut| {
-            tokio::spawn(fut);
-        })
-        .await
-        .unwrap();
+        dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+            .await
+            .unwrap();
 
         println!("Result: {}\n", dag.get(processed).unwrap());
     }
@@ -228,11 +225,9 @@ async fn main() {
             timeout_ms: 200,
         });
 
-        dag.run(|fut| {
-            tokio::spawn(fut);
-        })
-        .await
-        .unwrap();
+        dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+            .await
+            .unwrap();
 
         println!("Fast task 1: {:?}", dag.get(fast1).unwrap());
         println!("Fast task 2: {:?}", dag.get(fast2).unwrap());
@@ -254,11 +249,9 @@ async fn main() {
         let processed1 = dag.add_task(ProcessResult).depends_on(&source);
         let processed2 = dag.add_task(ProcessResult).depends_on(&source);
 
-        dag.run(|fut| {
-            tokio::spawn(fut);
-        })
-        .await
-        .unwrap();
+        dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+            .await
+            .unwrap();
 
         println!("Processed 1: {}", dag.get(processed1).unwrap());
         println!("Processed 2: {}\n", dag.get(processed2).unwrap());
@@ -277,9 +270,7 @@ async fn main() {
         let dag_timeout = Duration::from_millis(500);
         match timeout(
             dag_timeout,
-            dag.run(|fut| {
-                tokio::spawn(fut);
-            }),
+            dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)),
         )
         .await
         {

examples/tracing_example.rs

@@ -34,6 +34,7 @@
 //!
 
 use dagx::{task, DagRunner, Task};
+use futures::FutureExt;
 use tracing_subscriber::{fmt, EnvFilter};
 
 // Simple source task
@@ -95,11 +96,9 @@ async fn main() {
         // Layer 2: Combine results
         let result = dag.add_task(Add).depends_on((&left, &right));
 
-        dag.run(|fut| {
-            tokio::spawn(fut);
-        })
-        .await
-        .unwrap();
+        dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+            .await
+            .unwrap();
 
         println!("\nResult: {}", dag.get(result).unwrap());
         println!("(Expected: 10+10 = 20, 10*10 = 100, 20+100 = 120)\n");
@@ -118,11 +117,9 @@ async fn main() {
         let c = dag.add_task(Multiply).depends_on((&b, &b));
         let d = dag.add_task(Add).depends_on((&c, &c));
 
-        dag.run(|fut| {
-            tokio::spawn(fut);
-        })
-        .await
-        .unwrap();
+        dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+            .await
+            .unwrap();
 
         println!("\nResult: {}", dag.get(d).unwrap());
         println!("(Expected: 1+1 = 2, 2*2 = 4, 4+4 = 8)\n");
@@ -149,11 +146,9 @@ async fn main() {
         let sum_all = dag.add_task(Add).depends_on((&sum12, &sum23));
         let final_result = dag.add_task(Add).depends_on((&sum_all, &sum34));
 
-        dag.run(|fut| {
-            tokio::spawn(fut);
-        })
-        .await
-        .unwrap();
+        dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
+            .await
+            .unwrap();
 
         println!("\nResult: {}", dag.get(final_result).unwrap());
         println!("(Expected: (1+2)+(2+3) = 8, 8+(3+4) = 15)\n");