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

benches/comparisons/deep_chain.rs

@@ -20,19 +20,19 @@ pub fn bench_deep_chain(c: &mut Criterion) {
                 let first = dag.add_task(task_fn::<(), _, _>(|_: ()| 0));
                 let mut prev = dag
                     .add_task(task_fn::<i32, _, _>(|&x: &i32| x + 1))
-                    .depends_on(first);
+                    .depends_on(&first);
 
                 for i in 2..100 {
                     prev = dag
                         .add_task(task_fn::<i32, _, _>(move |&x: &i32| x + i))
-                        .depends_on(prev);
+                        .depends_on(&prev);
                 }
 
                 let mut output = dag
                     .run(|fut| async move { tokio::spawn(fut).await.unwrap() })
                     .await
                     .unwrap();
-                output.get(prev).unwrap()
+                output.get(prev)
             })
         });
     });

benches/comparisons/diamond_pattern.rs

@@ -20,19 +20,19 @@ pub fn bench_diamond_pattern(c: &mut Criterion) {
                 let a = dag.add_task(task_fn::<(), _, _>(|_: ()| 10));
                 let b = dag
                     .add_task(task_fn::<i32, _, _>(|&x: &i32| x * 2))
-                    .depends_on(a);
+                    .depends_on(&a);
                 let c = dag
                     .add_task(task_fn::<i32, _, _>(|&x: &i32| x + 5))
-                    .depends_on(a);
+                    .depends_on(&a);
                 let d = dag
                     .add_task(task_fn::<(i32, i32), _, _>(|(x, y): (&i32, &i32)| x + y))
-                    .depends_on((b, c));
+                    .depends_on((&b, &c));
 
                 let mut output = dag
                     .run(|fut| async move { tokio::spawn(fut).await.unwrap() })
                     .await
                     .unwrap();
-                output.get(d).unwrap()
+                output.get(d)
             })
         });
     });

benches/comparisons/etl_pipeline.rs

@@ -27,19 +27,19 @@ pub fn bench_etl_pipeline(c: &mut Criterion) {
                     .add_task(task_fn::<Vec<_>, _, _>(|data: &Vec<i32>| {
                         data.iter().map(|x| x * 2).collect::<Vec<_>>()
                     }))
-                    .depends_on(source1);
+                    .depends_on(&source1);
 
                 let transform2 = dag
                     .add_task(task_fn::<Vec<_>, _, _>(|data: &Vec<i32>| {
                         data.iter().map(|x| x * 2).collect::<Vec<_>>()
                     }))
-                    .depends_on(source2);
+                    .depends_on(&source2);
 
                 let transform3 = dag
                     .add_task(task_fn::<Vec<_>, _, _>(|data: &Vec<i32>| {
                         data.iter().map(|x| x * 2).collect::<Vec<_>>()
                     }))
-                    .depends_on(source3);
+                    .depends_on(&source3);
 
                 // Merge all transformed data
                 let merge = dag
@@ -51,7 +51,7 @@ pub fn bench_etl_pipeline(c: &mut Criterion) {
                             result
                         },
                     ))
-                    .depends_on((transform1, transform2, transform3));
+                    .depends_on((&transform1, &transform2, &transform3));
 
                 // Validate
                 let validate = dag
@@ -61,20 +61,20 @@ pub fn bench_etl_pipeline(c: &mut Criterion) {
                             .filter(|&x| x > 0)
                             .collect::<Vec<i32>>()
                     }))
-                    .depends_on(merge);
+                    .depends_on(&merge);
 
                 // Load (compute sum)
                 let load = dag
                     .add_task(task_fn::<Vec<_>, _, _>(|data: &Vec<i32>| {
                         data.iter().sum::<i32>()
                     }))
-                    .depends_on(validate);
+                    .depends_on(&validate);
 
                 let mut output = dag
                     .run(|fut| async move { tokio::spawn(fut).await.unwrap() })
                     .await
                     .unwrap();
-                output.get(load).unwrap()
+                output.get(load)
             })
         });
     });

benches/comparisons/linear_pipeline.rs

@@ -20,22 +20,22 @@ pub fn bench_linear_pipeline(c: &mut Criterion) {
                 let a = dag.add_task(task_fn::<(), _, _>(|_: ()| 1));
                 let b = dag
                     .add_task(task_fn::<i32, _, _>(|&x: &i32| x + 1))
-                    .depends_on(a);
+                    .depends_on(&a);
                 let c = dag
                     .add_task(task_fn::<i32, _, _>(|&x: &i32| x * 2))
-                    .depends_on(b);
+                    .depends_on(&b);
                 let d = dag
                     .add_task(task_fn::<i32, _, _>(|&x: &i32| x - 1))
-                    .depends_on(c);
+                    .depends_on(&c);
                 let e = dag
                     .add_task(task_fn::<i32, _, _>(|&x: &i32| x * 3))
-                    .depends_on(d);
+                    .depends_on(&d);
 
                 let mut output = dag
                     .run(|fut| async move { tokio::spawn(fut).await.unwrap() })
                     .await
                     .unwrap();
-                output.get(e).unwrap()
+                output.get(e)
             })
         });
     });

benches/comparisons/wide_fanout.rs

@@ -21,7 +21,7 @@ pub fn bench_wide_fanout(c: &mut Criterion) {
                 // Create 100 tasks that all depend on source
                 for i in 0..100 {
                     dag.add_task(task_fn::<i32, _, _>(move |&x: &i32| x + i))
-                        .depends_on(source);
+                        .depends_on(&source);
                 }
 
                 let _output = dag

benches/patterns/diamond.rs

@@ -16,13 +16,13 @@ pub fn bench_diamond(c: &mut Criterion) {
 
                     let left = dag
                         .add_task(task_fn::<i32, _, _>(|&x: &i32| x * 2))
-                        .depends_on(source);
+                        .depends_on(&source);
                     let right = dag
                         .add_task(task_fn::<i32, _, _>(|&x: &i32| x * 3))
-                        .depends_on(source);
+                        .depends_on(&source);
 
                     dag.add_task(task_fn::<(i32, i32), _, _>(|(l, r): (&i32, &i32)| l + r))
-                        .depends_on((left, right));
+                        .depends_on((&left, &right));
                 }
 
                 let _output = dag

benches/patterns/fanout.rs

@@ -15,7 +15,7 @@ pub fn bench_fanout(c: &mut Criterion) {
 
                 for i in 0..100 {
                     dag.add_task(task_fn::<i32, _, _>(move |&x: &i32| x + i))
-                        .depends_on(source);
+                        .depends_on(&source);
                 }
 
                 let _output = dag
@@ -41,7 +41,7 @@ pub fn bench_fanout(c: &mut Criterion) {
                         // Each consumer gets data extracted from Arc
                         data.iter().filter(|s| s.contains(&i.to_string())).count()
                     }))
-                    .depends_on(source);
+                    .depends_on(&source);
                 }
 
                 let _output = dag

benches/realistic/etl.rs

@@ -46,7 +46,7 @@ pub fn bench_etl_pipeline(c: &mut Criterion) {
                                     })
                                     .count()
                             }))
-                            .depends_on(extract);
+                            .depends_on(&extract);
 
                         // T2: Extract scores
                         let scores = dag
@@ -59,7 +59,7 @@ pub fn bench_etl_pipeline(c: &mut Criterion) {
                                     })
                                     .collect::<Vec<_>>()
                             }))
-                            .depends_on(extract);
+                            .depends_on(&extract);
 
                         // T3: Extract names
                         let names = dag
@@ -73,7 +73,7 @@ pub fn bench_etl_pipeline(c: &mut Criterion) {
                                     })
                                     .collect::<Vec<_>>()
                             }))
-                            .depends_on(extract);
+                            .depends_on(&extract);
 
                         // Load: Aggregate all transformations
                         dag.add_task(task_fn::<(usize, Vec<_>, Vec<_>), _, _>(
@@ -88,7 +88,7 @@ pub fn bench_etl_pipeline(c: &mut Criterion) {
                                 )
                             },
                         ))
-                        .depends_on((validate, scores, names));
+                        .depends_on((&validate, &scores, &names));
 
                         let _output = dag
                             .run(|fut| async move { tokio::spawn(fut).await.unwrap() })

benches/realistic/memory_efficiency.rs

@@ -36,7 +36,7 @@ pub fn bench_memory_efficiency(c: &mut Criterion) {
                                     .sum();
                                 black_box(sample_sum)
                             }))
-                            .depends_on(source);
+                            .depends_on(&source);
                         }
 
                         let _output = dag

benches/realistic/mixed.rs

@@ -23,17 +23,17 @@ pub fn bench_mixed_patterns(c: &mut Criterion) {
                     .add_task(task_fn::<Vec<_>, _, _>(|d: &Vec<String>| {
                         d.iter().filter(|s| s.contains("00")).count()
                     }))
-                    .depends_on(data);
+                    .depends_on(&data);
 
                 let analysis2 = dag
                     .add_task(task_fn::<Vec<_>, _, _>(|d: &Vec<String>| {
                         d.iter().map(|s| s.len()).sum::<usize>()
                     }))
-                    .depends_on(data);
+                    .depends_on(&data);
 
                 let analysis3 = dag
                     .add_task(task_fn::<Vec<_>, _, _>(|d: &Vec<String>| d.len()))
-                    .depends_on(data);
+                    .depends_on(&data);
 
                 // Stage 3: Fan-in to aggregate
                 let summary = dag
@@ -42,14 +42,14 @@ pub fn bench_mixed_patterns(c: &mut Criterion) {
                             format!("Matches: {}, Total bytes: {}, Count: {}", a1, a2, a3)
                         },
                     ))
-                    .depends_on((analysis1, analysis2, analysis3));
+                    .depends_on((&analysis1, &analysis2, &analysis3));
 
                 // Stage 4: Fan-out final report to multiple destinations
                 for i in 0..3 {
                     dag.add_task(task_fn::<String, _, _>(move |report: &String| {
                         format!("Destination {}: {}", i, report)
                     }))
-                    .depends_on(summary);
+                    .depends_on(&summary);
                 }
 
                 let _output = dag