test: update tests/examples/benches

benches/basic/creation.rs

@@ -21,7 +21,7 @@ pub fn bench_dag_creation(c: &mut Criterion) {
 
     c.bench_function("add_100_tasks", |b| {
         b.iter(|| {
-            let dag = DagRunner::new();
+            let mut dag = DagRunner::new();
             for i in 0..100 {
                 black_box(dag.add_task(Value(i)));
             }

benches/basic/scaling.rs

@@ -15,11 +15,12 @@ pub fn bench_dag_scaling(c: &mut Criterion) {
         group.bench_with_input(BenchmarkId::from_parameter(size), size, |b, &size| {
             b.iter(|| {
                 rt.block_on(async {
-                    let dag = DagRunner::new();
+                    let mut dag = DagRunner::new();
                     for i in 0..size {
                         dag.add_task(task_fn::<(), _, _>(move |_: ()| i));
                     }
-                    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+                    let _output = dag
+                        .run(|fut| async move { tokio::spawn(fut).await.unwrap() })
                         .await
                         .unwrap();
                 })

benches/comparisons/deep_chain.rs

@@ -3,7 +3,6 @@
 //! Long sequential chain: 100 tasks in sequence
 
 use criterion::Criterion;
-use dagx::TaskHandle;
 
 pub fn bench_deep_chain(c: &mut Criterion) {
     let rt = tokio::runtime::Runtime::new().unwrap();
@@ -16,9 +15,9 @@ pub fn bench_deep_chain(c: &mut Criterion) {
                 use dagx::DagRunner;
                 use dagx_test::task_fn;
 
-                let dag = DagRunner::new();
+                let mut dag = DagRunner::new();
 
-                let first: TaskHandle<_> = dag.add_task(task_fn::<(), _, _>(|_: ()| 0)).into();
+                let first = dag.add_task(task_fn::<(), _, _>(|_: ()| 0));
                 let mut prev = dag
                     .add_task(task_fn::<i32, _, _>(|&x: &i32| x + 1))
                     .depends_on(first);
@@ -29,10 +28,11 @@ pub fn bench_deep_chain(c: &mut Criterion) {
                         .depends_on(prev);
                 }
 
-                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();
-                dag.get(prev).unwrap()
+                output.get(prev).unwrap()
             })
         });
     });

benches/comparisons/diamond_pattern.rs

@@ -3,7 +3,6 @@
 //! Classic diamond: A → B,C → D
 
 use criterion::Criterion;
-use dagx::TaskHandle;
 
 pub fn bench_diamond_pattern(c: &mut Criterion) {
     let rt = tokio::runtime::Runtime::new().unwrap();
@@ -16,9 +15,9 @@ pub fn bench_diamond_pattern(c: &mut Criterion) {
                 use dagx::DagRunner;
                 use dagx_test::task_fn;
 
-                let dag = DagRunner::new();
+                let mut dag = DagRunner::new();
 
-                let a: TaskHandle<_> = dag.add_task(task_fn::<(), _, _>(|_: ()| 10)).into();
+                let a = dag.add_task(task_fn::<(), _, _>(|_: ()| 10));
                 let b = dag
                     .add_task(task_fn::<i32, _, _>(|&x: &i32| x * 2))
                     .depends_on(a);
@@ -29,10 +28,11 @@ pub fn bench_diamond_pattern(c: &mut Criterion) {
                     .add_task(task_fn::<(i32, i32), _, _>(|(x, y): (&i32, &i32)| x + y))
                     .depends_on((&b, &c));
 
-                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();
-                dag.get(d).unwrap()
+                output.get(d).unwrap()
             })
         });
     });

benches/comparisons/etl_pipeline.rs

@@ -15,7 +15,7 @@ pub fn bench_etl_pipeline(c: &mut Criterion) {
                 use dagx::DagRunner;
                 use dagx_test::task_fn;
 
-                let dag = DagRunner::new();
+                let mut dag = DagRunner::new();
 
                 // Extract from 3 sources
                 let source1 = dag.add_task(task_fn::<(), _, _>(|_: ()| vec![1, 2, 3, 4, 5]));
@@ -70,10 +70,11 @@ pub fn bench_etl_pipeline(c: &mut Criterion) {
                     }))
                     .depends_on(validate);
 
-                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();
-                dag.get(load).unwrap()
+                output.get(load).unwrap()
             })
         });
     });

benches/comparisons/large_scale.rs

@@ -17,12 +17,13 @@ pub fn bench_large_scale(c: &mut Criterion) {
                 use dagx::DagRunner;
                 use dagx_test::task_fn;
 
-                let dag = DagRunner::new();
+                let mut dag = DagRunner::new();
                 for i in 0..10_000 {
                     dag.add_task(task_fn::<(), _, _>(move |_: ()| i * 2));
                 }
 
-                dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+                let _output = dag
+                    .run(|fut| async move { tokio::spawn(fut).await.unwrap() })
                     .await
                     .unwrap();
             })

benches/comparisons/linear_pipeline.rs

@@ -15,7 +15,7 @@ pub fn bench_linear_pipeline(c: &mut Criterion) {
                 use dagx::DagRunner;
                 use dagx_test::task_fn;
 
-                let dag = DagRunner::new();
+                let mut dag = DagRunner::new();
 
                 let a = dag.add_task(task_fn::<(), _, _>(|_: ()| 1));
                 let b = dag
@@ -31,10 +31,11 @@ pub fn bench_linear_pipeline(c: &mut Criterion) {
                     .add_task(task_fn::<i32, _, _>(|&x: &i32| x * 3))
                     .depends_on(d);
 
-                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();
-                dag.get(e).unwrap()
+                output.get(e).unwrap()
             })
         });
     });

benches/comparisons/wide_fanout.rs

@@ -3,7 +3,6 @@
 //! One source task feeding 100 dependent tasks
 
 use criterion::Criterion;
-use dagx::TaskHandle;
 
 pub fn bench_wide_fanout(c: &mut Criterion) {
     let rt = tokio::runtime::Runtime::new().unwrap();
@@ -16,8 +15,8 @@ pub fn bench_wide_fanout(c: &mut Criterion) {
                 use dagx::DagRunner;
                 use dagx_test::task_fn;
 
-                let dag = DagRunner::new();
-                let source: TaskHandle<_> = dag.add_task(task_fn::<(), _, _>(|_: ()| 42)).into();
+                let mut dag = DagRunner::new();
+                let source = dag.add_task(task_fn::<(), _, _>(|_: ()| 42));
 
                 // Create 100 tasks that all depend on source
                 for i in 0..100 {
@@ -25,7 +24,8 @@ pub fn bench_wide_fanout(c: &mut Criterion) {
                         .depends_on(source);
                 }
 
-                dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+                let _output = dag
+                    .run(|fut| async move { tokio::spawn(fut).await.unwrap() })
                     .await
                     .unwrap();
             })

benches/patterns/breakdown.rs

@@ -12,7 +12,7 @@ pub fn bench_10k_breakdown(c: &mut Criterion) {
     // a) Adding 10k tasks (construction only)
     group.bench_function("construction", |b| {
         b.iter(|| {
-            let dag = DagRunner::new();
+            let mut dag = DagRunner::new();
             for i in 0..10_000 {
                 dag.add_task(task_fn::<(), _, _>(move |_: ()| i));
             }
@@ -23,11 +23,12 @@ pub fn bench_10k_breakdown(c: &mut Criterion) {
     group.bench_function("full_execution", |b| {
         b.iter(|| {
             rt.block_on(async {
-                let dag = DagRunner::new();
+                let mut dag = DagRunner::new();
                 for i in 0..10_000 {
                     dag.add_task(task_fn::<(), _, _>(move |_: ()| i));
                 }
-                dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+                let _output = dag
+                    .run(|fut| async move { tokio::spawn(fut).await.unwrap() })
                     .await
                     .unwrap();
             })
@@ -38,7 +39,7 @@ pub fn bench_10k_breakdown(c: &mut Criterion) {
     group.bench_function("execution_only", |b| {
         b.iter_batched(
             || {
-                let dag = DagRunner::new();
+                let mut dag = DagRunner::new();
                 for i in 0..10_000 {
                     dag.add_task(task_fn::<(), _, _>(move |_: ()| i));
                 }
@@ -46,7 +47,8 @@ pub fn bench_10k_breakdown(c: &mut Criterion) {
             },
             |dag| {
                 rt.block_on(async {
-                    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+                    let _output = dag
+                        .run(|fut| async move { tokio::spawn(fut).await.unwrap() })
                         .await
                         .unwrap();
                 })

benches/patterns/diamond.rs

@@ -1,7 +1,7 @@
 //! Diamond pattern benchmarks (fan-out then fan-in)
 
 use criterion::Criterion;
-use dagx::{DagRunner, TaskHandle};
+use dagx::DagRunner;
 use dagx_test::task_fn;
 pub fn bench_diamond(c: &mut Criterion) {
     let rt = tokio::runtime::Runtime::new().unwrap();
@@ -9,11 +9,10 @@ pub fn bench_diamond(c: &mut Criterion) {
     c.bench_function("diamond_pattern_50", |b| {
         b.iter(|| {
             rt.block_on(async {
-                let dag = DagRunner::new();
+                let mut dag = DagRunner::new();
 
                 for i in 0..50 {
-                    let source: TaskHandle<_> =
-                        dag.add_task(task_fn::<(), _, _>(move |_: ()| i)).into();
+                    let source = dag.add_task(task_fn::<(), _, _>(move |_: ()| i));
 
                     let left = dag
                         .add_task(task_fn::<i32, _, _>(|&x: &i32| x * 2))
@@ -26,7 +25,8 @@ pub fn bench_diamond(c: &mut Criterion) {
                         .depends_on((&left, &right));
                 }
 
-                dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+                let _output = dag
+                    .run(|fut| async move { tokio::spawn(fut).await.unwrap() })
                     .await
                     .unwrap();
             })

benches/patterns/fanout.rs

@@ -1,7 +1,7 @@
 //! Fan-out pattern benchmarks (1 → N dependencies)
 
 use criterion::Criterion;
-use dagx::{DagRunner, TaskHandle};
+use dagx::DagRunner;
 use dagx_test::task_fn;
 pub fn bench_fanout(c: &mut Criterion) {
     let rt = tokio::runtime::Runtime::new().unwrap();
@@ -10,15 +10,16 @@ pub fn bench_fanout(c: &mut Criterion) {
     c.bench_function("fanout_1_to_100_i32", |b| {
         b.iter(|| {
             rt.block_on(async {
-                let dag = DagRunner::new();
-                let source: TaskHandle<_> = dag.add_task(task_fn::<(), _, _>(|_: ()| 42)).into();
+                let mut dag = DagRunner::new();
+                let source = dag.add_task(task_fn::<(), _, _>(|_: ()| 42));
 
                 for i in 0..100 {
                     dag.add_task(task_fn::<i32, _, _>(move |&x: &i32| x + i))
                         .depends_on(source);
                 }
 
-                dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+                let _output = dag
+                    .run(|fut| async move { tokio::spawn(fut).await.unwrap() })
                     .await
                     .unwrap();
             })
@@ -29,13 +30,11 @@ pub fn bench_fanout(c: &mut Criterion) {
     c.bench_function("fanout_1_to_100_vec", |b| {
         b.iter(|| {
             rt.block_on(async {
-                let dag = DagRunner::new();
-                let source: TaskHandle<_> = dag
-                    .add_task(task_fn::<(), _, _>(|_: ()| {
-                        // Create 1000 strings - framework wraps in Arc automatically
-                        (0..1000).map(|i| format!("Item {}", i)).collect::<Vec<_>>()
-                    }))
-                    .into();
+                let mut dag = DagRunner::new();
+                let source = dag.add_task(task_fn::<(), _, _>(|_: ()| {
+                    // Create 1000 strings - framework wraps in Arc automatically
+                    (0..1000).map(|i| format!("Item {}", i)).collect::<Vec<_>>()
+                }));
 
                 for i in 0..100 {
                     dag.add_task(task_fn::<Vec<_>, _, _>(move |data: &Vec<String>| {
@@ -45,7 +44,8 @@ pub fn bench_fanout(c: &mut Criterion) {
                     .depends_on(source);
                 }
 
-                dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+                let _output = dag
+                    .run(|fut| async move { tokio::spawn(fut).await.unwrap() })
                     .await
                     .unwrap();
             })

benches/realistic/etl.rs

@@ -1,7 +1,7 @@
 //! ETL (Extract, Transform, Load) pipeline benchmark
 
 use criterion::{BenchmarkId, Criterion};
-use dagx::{DagRunner, TaskHandle};
+use dagx::DagRunner;
 use dagx_test::task_fn;
 pub fn bench_etl_pipeline(c: &mut Criterion) {
     let rt = tokio::runtime::Runtime::new().unwrap();
@@ -17,23 +17,21 @@ pub fn bench_etl_pipeline(c: &mut Criterion) {
             |b, &count| {
                 b.iter(|| {
                     rt.block_on(async {
-                        let dag = DagRunner::new();
+                        let mut dag = DagRunner::new();
 
                         // Extract: Load JSON-like data (framework wraps in Arc automatically)
-                        let extract: TaskHandle<_> = dag
-                            .add_task(task_fn::<(), _, _>(move |_: ()| {
-                                (0..count)
-                                    .map(|i| {
-                                        format!(
-                                            "{{\"id\":{},\"name\":\"User{}\",\"score\":{}}}",
-                                            i,
-                                            i,
-                                            i * 10
-                                        )
-                                    })
-                                    .collect::<Vec<_>>()
-                            }))
-                            .into();
+                        let extract = dag.add_task(task_fn::<(), _, _>(move |_: ()| {
+                            (0..count)
+                                .map(|i| {
+                                    format!(
+                                        "{{\"id\":{},\"name\":\"User{}\",\"score\":{}}}",
+                                        i,
+                                        i,
+                                        i * 10
+                                    )
+                                })
+                                .collect::<Vec<_>>()
+                        }));
 
                         // Transform: Three parallel transformations
 
@@ -92,7 +90,8 @@ pub fn bench_etl_pipeline(c: &mut Criterion) {
                         ))
                         .depends_on((&validate, &scores, &names));
 
-                        dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+                        let _output = dag
+                            .run(|fut| async move { tokio::spawn(fut).await.unwrap() })
                             .await
                             .unwrap();
                     })

benches/realistic/memory_efficiency.rs

@@ -1,7 +1,7 @@
 //! Memory efficiency benchmark with large data structures
 
 use criterion::{BenchmarkId, Criterion};
-use dagx::{DagRunner, TaskHandle};
+use dagx::DagRunner;
 use dagx_test::task_fn;
 use std::hint::black_box;
 
@@ -10,21 +10,19 @@ pub fn bench_memory_efficiency(c: &mut Criterion) {
     let mut group = c.benchmark_group("memory_efficiency");
 
     // Test with different data sizes (in MB)
-    for mb_size in [1, 5, 10].iter() {
+    for mb_size in [1, 10].iter() {
         group.bench_with_input(
             BenchmarkId::new("large_data_20_consumers", format!("{}MB", mb_size)),
             mb_size,
             |b, &mb| {
                 b.iter(|| {
                     rt.block_on(async {
-                        let dag = DagRunner::new();
+                        let mut dag = DagRunner::new();
 
-                        let source: TaskHandle<_> = dag
-                            .add_task(task_fn::<(), _, _>(move |_: ()| {
-                                // Create MB of data - framework wraps in Arc automatically
-                                vec![0u8; mb * 1024 * 1024]
-                            }))
-                            .into();
+                        let source = dag.add_task(task_fn::<(), _, _>(move |_: ()| {
+                            // Create MB of data - framework wraps in Arc automatically
+                            vec![0u8; mb * 1024 * 1024]
+                        }));
 
                         // 20 consumers share the data via automatic Arc wrapping
                         for i in 0..20 {
@@ -41,7 +39,8 @@ pub fn bench_memory_efficiency(c: &mut Criterion) {
                             .depends_on(source);
                         }
 
-                        dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+                        let _output = dag
+                            .run(|fut| async move { tokio::spawn(fut).await.unwrap() })
                             .await
                             .unwrap();
                     })

benches/realistic/mixed.rs

@@ -1,7 +1,7 @@
 //! Mixed realistic patterns - fan-out, fan-in, and processing
 
 use criterion::Criterion;
-use dagx::{DagRunner, TaskHandle};
+use dagx::DagRunner;
 use dagx_test::task_fn;
 pub fn bench_mixed_patterns(c: &mut Criterion) {
     let rt = tokio::runtime::Runtime::new().unwrap();
@@ -9,16 +9,14 @@ pub fn bench_mixed_patterns(c: &mut Criterion) {
     c.bench_function("mixed_patterns_realistic", |b| {
         b.iter(|| {
             rt.block_on(async {
-                let dag = DagRunner::new();
+                let mut dag = DagRunner::new();
 
                 // Stage 1: Load data (framework wraps in Arc automatically)
-                let data: TaskHandle<_> = dag
-                    .add_task(task_fn::<(), _, _>(|_: ()| {
-                        (0..1000)
-                            .map(|i| format!("Record-{:04}", i))
-                            .collect::<Vec<_>>()
-                    }))
-                    .into();
+                let data = dag.add_task(task_fn::<(), _, _>(|_: ()| {
+                    (0..1000)
+                        .map(|i| format!("Record-{:04}", i))
+                        .collect::<Vec<_>>()
+                }));
 
                 // Stage 2: Fan-out for parallel analysis
                 let analysis1 = dag
@@ -54,7 +52,8 @@ pub fn bench_mixed_patterns(c: &mut Criterion) {
                     .depends_on(summary);
                 }
 
-                dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+                let _output = dag
+                    .run(|fut| async move { tokio::spawn(fut).await.unwrap() })
                     .await
                     .unwrap();
             })