chore: clean up in preparation for release

tests/boundaries/deep_chains.rs

@@ -41,14 +41,14 @@ async fn test_multiple_parallel_deep_chains() -> DagResult<()> {
             },
         ))
         .depends_on((
-            &chain_ends[0],
-            &chain_ends[1],
-            &chain_ends[2],
-            &chain_ends[3],
-            &chain_ends[4],
-            &chain_ends[5],
-            &chain_ends[6],
-            &chain_ends[7],
+            chain_ends[0],
+            chain_ends[1],
+            chain_ends[2],
+            chain_ends[3],
+            chain_ends[4],
+            chain_ends[5],
+            chain_ends[6],
+            chain_ends[7],
         ));
 
     let mut output = dag
@@ -120,7 +120,7 @@ async fn test_deep_binary_tree() -> DagResult<()> {
             dag.add_task(task_fn::<(i32, i32), _, _>(move |(l, r): (&i32, &i32)| {
                 l + r
             }))
-            .depends_on((&left, &right))
+            .depends_on((left, right))
         }
     }
 
@@ -152,7 +152,7 @@ async fn test_fibonacci_chain() -> DagResult<()> {
     for _ in 2..50 {
         let next = dag
             .add_task(task_fn::<(i64, i64), _, _>(|(a, b): (&i64, &i64)| a + b))
-            .depends_on((&prev2, &prev1));
+            .depends_on((prev2, prev1));
 
         prev2 = prev1;
         prev1 = next;
@@ -196,7 +196,7 @@ async fn test_zigzag_dependencies() -> DagResult<()> {
     // Final task depends on both chains
     let final_task = dag
         .add_task(task_fn::<(i32, i32), _, _>(|(a, b): (&i32, &i32)| a + b))
-        .depends_on((&chain_a, &chain_b));
+        .depends_on((chain_a, chain_b));
 
     let mut output = dag
         .run(|fut| async move { tokio::spawn(fut).await.unwrap() })

tests/cycle_prevention.rs

@@ -267,7 +267,7 @@ async fn test_type_safety_prevents_invalid_graphs() {
     let t2 = dag.add_task(Transform).depends_on(s2);
 
     // Aggregate depends on transforms
-    let result = dag.add_task(Aggregate).depends_on((&t1, &t2));
+    let result = dag.add_task(Aggregate).depends_on((t1, t2));
 
     // Execute and verify
     let mut output = dag

tests/dependencies/tuples.rs

@@ -54,7 +54,7 @@ async fn test_four_dependencies() -> DagResult<()> {
         .add_task(task_fn::<(i32, i32, i32, i32), _, _>(
             |(a, b, c, d): (&i32, &i32, &i32, &i32)| a + b + c + d,
         ))
-        .depends_on((&deps[0], &deps[1], &deps[2], &deps[3]));
+        .depends_on((deps[0], deps[1], deps[2], deps[3]));
 
     let mut output = dag
         .run(|fut| async move { tokio::spawn(fut).await.unwrap() })
@@ -76,7 +76,7 @@ async fn test_five_dependencies() -> DagResult<()> {
         .add_task(task_fn::<(i32, i32, i32, i32, i32), _, _>(
             |(a, b, c, d, e): (&i32, &i32, &i32, &i32, &i32)| a + b + c + d + e,
         ))
-        .depends_on((&deps[0], &deps[1], &deps[2], &deps[3], &deps[4]));
+        .depends_on((deps[0], deps[1], deps[2], deps[3], deps[4]));
 
     let mut output = dag
         .run(|fut| async move { tokio::spawn(fut).await.unwrap() })
@@ -98,7 +98,7 @@ async fn test_six_dependencies() -> DagResult<()> {
         .add_task(task_fn::<(i32, i32, i32, i32, i32, i32), _, _>(
             |(a, b, c, d, e, f): (&i32, &i32, &i32, &i32, &i32, &i32)| a + b + c + d + e + f,
         ))
-        .depends_on((&deps[0], &deps[1], &deps[2], &deps[3], &deps[4], &deps[5]));
+        .depends_on((deps[0], deps[1], deps[2], deps[3], deps[4], deps[5]));
 
     let mut output = dag
         .run(|fut| async move { tokio::spawn(fut).await.unwrap() })
@@ -123,7 +123,7 @@ async fn test_seven_dependencies() -> DagResult<()> {
             },
         ))
         .depends_on((
-            &deps[0], &deps[1], &deps[2], &deps[3], &deps[4], &deps[5], &deps[6],
+            deps[0], deps[1], deps[2], deps[3], deps[4], deps[5], deps[6],
         ));
 
     let mut output = dag
@@ -149,7 +149,7 @@ async fn test_eight_dependencies() -> DagResult<()> {
             },
         ))
         .depends_on((
-            &deps[0], &deps[1], &deps[2], &deps[3], &deps[4], &deps[5], &deps[6], &deps[7],
+            deps[0], deps[1], deps[2], deps[3], deps[4], deps[5], deps[6], deps[7],
         ));
 
     let mut output = dag

tests/errors/propagation.rs

@@ -53,7 +53,7 @@ async fn test_diamond_error_propagation() {
         .depends_on(source);
 
     dag.add_task(task_fn::<(i32, i32), _, _>(|(l, r): (&i32, &i32)| l + r))
-        .depends_on((&left, &right));
+        .depends_on((left, right));
 
     assert!(matches!(
         dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })

tests/execution/mod.rs

@@ -54,7 +54,7 @@ async fn test_diamond_dependency() {
         .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() })

tests/interleaving/mod.rs

@@ -255,7 +255,7 @@ async fn test_layered_interleaving() -> DagResult<()> {
             dag.add_task(Layer23Task {
                 active: layer_active.clone(),
             })
-            .depends_on((&layer1[idx], &layer1[idx + 1]))
+            .depends_on((layer1[idx], layer1[idx + 1]))
         })
         .collect();
 
@@ -264,7 +264,7 @@ async fn test_layered_interleaving() -> DagResult<()> {
         .add_task(Layer23Task {
             active: layer_active.clone(),
         })
-        .depends_on((&layer2[0], &layer2[1]));
+        .depends_on((layer2[0], layer2[1]));
 
     let mut output = dag
         .run(|fut| async move { tokio::spawn(fut).await.unwrap() })

tests/parallelism/timing.rs

@@ -140,7 +140,7 @@ async fn test_layers_execute_in_parallel() -> DagResult<()> {
                 a + b + c
             },
         ))
-        .depends_on((&layer1[0], &layer1[1], &layer1[2]))
+        .depends_on((layer1[0], layer1[1], layer1[2]))
     };
 
     let mut output = dag