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

tests/execution/mod.rs

@@ -20,7 +20,7 @@ async fn test_single_task() {
         .run(|fut| async move { tokio::spawn(fut).await.unwrap() })
         .await
         .unwrap();
-    assert_eq!(output.get(task).unwrap(), 42);
+    assert_eq!(output.get(task), 42);
 }
 
 #[tokio::test]
@@ -37,7 +37,7 @@ async fn test_wide_parallel() {
         .unwrap();
 
     for (i, task) in tasks.into_iter().enumerate() {
-        assert_eq!(output.get(task).unwrap(), i * 2);
+        assert_eq!(output.get(task), i * 2);
     }
 }
 
@@ -48,13 +48,13 @@ async fn test_diamond_dependency() {
     let a = dag.add_task(task_fn::<(), _, _>(|_: ()| 10));
     let b = dag
         .add_task(task_fn::<i32, _, _>(|&x: &i32| x + 5))
-        .depends_on(a);
+        .depends_on(&a);
     let c = dag
         .add_task(task_fn::<i32, _, _>(|&x: &i32| x * 2))
-        .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() })
@@ -63,7 +63,7 @@ async fn test_diamond_dependency() {
 
     // Note: a, b, and c are not sinks (they have dependents)
     // Only d is a sink and can be retrieved
-    assert_eq!(output.get(d).unwrap(), 35); // 15 + 20
+    assert_eq!(output.get(d), 35); // 15 + 20
 }
 
 #[derive(Clone)]
@@ -88,9 +88,9 @@ async fn test_different_output_types() {
         .await
         .unwrap();
 
-    assert_eq!(&output.get(string_task).unwrap(), "hello");
-    assert_eq!(output.get(vec_task).unwrap(), vec![1, 2, 3]);
-    let user = output.get(struct_task).unwrap();
+    assert_eq!(&output.get(string_task), "hello");
+    assert_eq!(output.get(vec_task), vec![1, 2, 3]);
+    let user = output.get(struct_task);
     assert_eq!(user.name, "Alice");
     assert_eq!(user.age, 30);
 }
@@ -104,26 +104,26 @@ async fn test_multiple_sinks() {
     // Branch 1
     let branch1 = dag
         .add_task(task_fn::<i32, _, _>(|&x: &i32| x * 2))
-        .depends_on(source);
+        .depends_on(&source);
     let sink1 = dag
         .add_task(task_fn::<i32, _, _>(|&x: &i32| x + 1))
-        .depends_on(branch1);
+        .depends_on(&branch1);
 
     // Branch 2
     let branch2 = dag
         .add_task(task_fn::<i32, _, _>(|&x: &i32| x + 5))
-        .depends_on(source);
+        .depends_on(&source);
     let sink2 = dag
         .add_task(task_fn::<i32, _, _>(|&x: &i32| x * 3))
-        .depends_on(branch2);
+        .depends_on(&branch2);
 
     let mut output = dag
         .run(|fut| async move { tokio::spawn(fut).await.unwrap() })
         .await
         .unwrap(); // Should wait for both sinks
 
-    assert_eq!(output.get(sink1).unwrap(), 21); // (10 * 2) + 1
-    assert_eq!(output.get(sink2).unwrap(), 45); // (10 + 5) * 3
+    assert_eq!(output.get(sink1), 21); // (10 * 2) + 1
+    assert_eq!(output.get(sink2), 45); // (10 + 5) * 3
 }
 
 #[tokio::test]
@@ -135,17 +135,17 @@ async fn test_single_task_inline_path() {
     let t1 = dag.add_task(task_fn::<(), _, _>(|_: ()| 10));
     let t2 = dag
         .add_task(task_fn::<i32, _, _>(|&x: &i32| x * 2))
-        .depends_on(t1);
+        .depends_on(&t1);
     let t3 = dag
         .add_task(task_fn::<i32, _, _>(|&x: &i32| x + 5))
-        .depends_on(t2);
+        .depends_on(&t2);
 
     let mut output = dag
         .run(|fut| async move { tokio::spawn(fut).await.unwrap() })
         .await
         .unwrap();
 
-    assert_eq!(output.get(t3).unwrap(), 25); // (10 * 2) + 5
+    assert_eq!(output.get(t3), 25); // (10 * 2) + 5
 }
 
 #[tokio::test]
@@ -158,20 +158,20 @@ async fn test_multi_consumer_fanout() {
     // Multiple consumers
     let c1 = dag
         .add_task(task_fn::<i32, _, _>(|&x: &i32| x * 2))
-        .depends_on(producer);
+        .depends_on(&producer);
     let c2 = dag
         .add_task(task_fn::<i32, _, _>(|&x: &i32| x + 10))
-        .depends_on(producer);
+        .depends_on(&producer);
     let c3 = dag
         .add_task(task_fn::<i32, _, _>(|&x: &i32| x - 5))
-        .depends_on(producer);
+        .depends_on(&producer);
 
     let mut output = dag
         .run(|fut| async move { tokio::spawn(fut).await.unwrap() })
         .await
         .unwrap();
 
-    assert_eq!(output.get(c1).unwrap(), 84);
-    assert_eq!(output.get(c2).unwrap(), 52);
-    assert_eq!(output.get(c3).unwrap(), 37);
+    assert_eq!(output.get(c1), 84);
+    assert_eq!(output.get(c2), 52);
+    assert_eq!(output.get(c3), 37);
 }