Depend on futures-util instead of futures

tests/boundaries/deep_chains.rs

@@ -2,7 +2,7 @@
 
 use crate::common::task_fn;
 use dagx::{DagResult, DagRunner};
-use futures::FutureExt;
+
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::Arc;
 
@@ -20,7 +20,7 @@ async fn test_1000_level_deep_chain() -> DagResult<()> {
             .depends_on(current);
     }
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() }).await?;
 
     assert_eq!(dag.get(current)?, 999);
     Ok(())
@@ -50,7 +50,7 @@ async fn test_deep_chain_with_branches() -> DagResult<()> {
         }
     }
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() }).await?;
 
     assert_eq!(dag.get(main_chain)?, 499);
 
@@ -108,7 +108,7 @@ async fn test_multiple_parallel_deep_chains() -> DagResult<()> {
             &chain_ends[7],
         ));
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() }).await?;
 
     // Each chain: start + 500
     // Chain 0: 0 + 500 = 500
@@ -149,7 +149,7 @@ async fn test_deep_chain_execution_order() -> DagResult<()> {
             .depends_on(current);
     }
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() }).await?;
 
     assert_eq!(order.load(Ordering::SeqCst), 100);
     assert_eq!(dag.get(current)?, 99);
@@ -179,7 +179,7 @@ async fn test_deep_binary_tree() -> DagResult<()> {
 
     let root = build_tree(&dag, 10, 1);
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() }).await?;
 
     // Sum of all values in a complete binary tree with values 1024..2047
     // This is sum from 2^10 to 2^11-1 = 1024 * 1023 / 2 + 1024 * 512 = 1047552
@@ -209,7 +209,7 @@ async fn test_fibonacci_chain() -> DagResult<()> {
         prev1 = next;
     }
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() }).await?;
 
     // 50th Fibonacci number (0-indexed) = 7778742049
     assert_eq!(dag.get(prev1)?, 7778742049);
@@ -232,7 +232,7 @@ async fn test_deep_chain_with_accumulator() -> DagResult<()> {
             .depends_on(current);
     }
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() }).await?;
 
     let result = dag.get(current)?;
     assert_eq!(result, 20100); // sum of 1..=200
@@ -270,7 +270,7 @@ async fn test_zigzag_dependencies() -> DagResult<()> {
         .add_task(task_fn::<(i32, i32), _, _>(|(a, b): (&i32, &i32)| a + b))
         .depends_on((&chain_a, &chain_b));
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() }).await?;
 
     let result = dag.get(final_task)?;
     assert!(result > 100);
@@ -293,7 +293,7 @@ async fn test_10000_level_chain_stress() -> DagResult<()> {
             .depends_on(current);
     }
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() }).await?;
 
     assert_eq!(dag.get(current)?, 9_999);
     Ok(())

tests/boundaries/large_scale.rs

@@ -2,7 +2,7 @@
 
 use crate::common::task_fn;
 use dagx::{DagResult, DagRunner};
-use futures::FutureExt;
+
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::Arc;
 
@@ -23,7 +23,7 @@ async fn test_10000_independent_tasks() -> DagResult<()> {
         })
         .collect();
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() }).await?;
 
     // Verify all tasks completed
     assert_eq!(counter.load(Ordering::Relaxed), 10_000);
@@ -100,7 +100,7 @@ async fn test_5000_node_pyramid() -> DagResult<()> {
         .add_task(task_fn::<(i32, i32), _, _>(|(a, b): (&i32, &i32)| a + b))
         .depends_on((&current_layer[0], &current_layer[1]));
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() }).await?;
 
     // We created 1024 ones and 1024 zeros at the bottom
     // The sum should propagate up to 1024
@@ -209,7 +209,7 @@ async fn test_wide_dag_1000_sources_1000_sinks() -> DagResult<()> {
         })
         .collect();
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() }).await?;
 
     // Verify some sinks completed correctly
     let result0 = dag.get(sinks[0])?;
@@ -258,7 +258,7 @@ async fn test_10000_node_linear_chain_segments() -> DagResult<()> {
         chain_ends.push(current);
     }
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() }).await?;
 
     // All 10,000 tasks should have executed
     assert_eq!(counter.load(Ordering::Relaxed), 10_000);
@@ -297,7 +297,7 @@ async fn test_100000_nodes_stress() -> DagResult<()> {
             .collect();
     }
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() }).await?;
 
     assert_eq!(completed.load(Ordering::Relaxed), 100_000);
     Ok(())

tests/boundaries/type_limits.rs

@@ -2,7 +2,7 @@
 
 use crate::common::task_fn;
 use dagx::{DagResult, DagRunner, TaskHandle};
-use futures::FutureExt;
+
 use std::marker::PhantomData;
 
 #[tokio::test]
@@ -37,7 +37,7 @@ async fn test_zero_sized_types_throughout() -> DagResult<()> {
         }))
         .depends_on(t2);
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() }).await?;
 
     assert_eq!(dag.get(t1)?, Empty);
     assert_eq!(dag.get(t2)?, 42);
@@ -72,7 +72,7 @@ async fn test_large_value_types() -> DagResult<()> {
         }))
         .depends_on(t1);
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() }).await?;
 
     assert_eq!(dag.get(t2)?, 1042);
 
@@ -95,7 +95,7 @@ async fn test_unit_type_chains() -> DagResult<()> {
         .add_task(task_fn::<(), _, _>(|_: ()| "done"))
         .depends_on((t3,));
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() }).await?;
 
     dag.get(t1)?; // Verify no error
     dag.get(t2)?;
@@ -145,7 +145,7 @@ async fn test_string_types_variety() -> DagResult<()> {
         ))
         .depends_on((t1, t2, t3, t4, t5, t6));
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() }).await?;
 
     let result = dag.get(combined)?;
     assert!(result.contains("static str"));
@@ -178,7 +178,7 @@ async fn test_generic_type_constraints() -> DagResult<()> {
         ))
         .depends_on((t1, t2, t3));
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() }).await?;
 
     let result = dag.get(combined)?;
     assert!(result.contains("Wrapper(42)"));
@@ -204,7 +204,7 @@ async fn test_reference_wrapper_types() -> DagResult<()> {
         .add_task(task_fn::<i32, _, _>(|&val: &i32| val * 2))
         .depends_on(t1);
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() }).await?;
 
     assert_eq!(dag.get(t2)?, 200);
 
@@ -231,7 +231,7 @@ async fn test_array_types() -> DagResult<()> {
         ))
         .depends_on((t1, t2));
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() }).await?;
 
     assert_eq!(dag.get(t3)?, 55);
 
@@ -270,7 +270,7 @@ async fn test_enum_variants() -> DagResult<()> {
         ))
         .depends_on((t1, t2, t3, t4));
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() }).await?;
 
     assert!(dag.get(combined)?);
 

tests/boundaries/zero_tasks.rs

@@ -2,7 +2,7 @@
 
 use crate::common::task_fn;
 use dagx::{task, DagResult, DagRunner};
-use futures::FutureExt;
+
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::Arc;
 use tokio::task::yield_now;
@@ -12,7 +12,7 @@ async fn test_empty_dag_execution() -> DagResult<()> {
     // Test that an empty DAG can be created and run without issues
     let dag = DagRunner::new();
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() }).await?;
 
     // Should complete successfully with no tasks
     Ok(())
@@ -25,7 +25,7 @@ async fn test_single_task_no_deps() -> DagResult<()> {
 
     let task = dag.add_task(task_fn::<(), _, _>(|_: ()| 42));
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() }).await?;
 
     assert_eq!(dag.get(task)?, 42);
     Ok(())
@@ -44,7 +44,7 @@ async fn test_single_task_unit_input_output() -> DagResult<()> {
         exec.fetch_add(1, Ordering::SeqCst);
     }));
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() }).await?;
 
     dag.get(task)?; // Just verify it doesn't error
     assert_eq!(executed.load(Ordering::SeqCst), 1);
@@ -61,7 +61,7 @@ async fn test_zero_sized_type_task() -> DagResult<()> {
 
     let task = dag.add_task(task_fn::<(), _, _>(|_: ()| ZeroSized));
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() }).await?;
 
     assert_eq!(dag.get(task)?, ZeroSized);
     Ok(())
@@ -73,7 +73,7 @@ async fn test_empty_dag_multiple_runs() -> DagResult<()> {
     let dag = DagRunner::new();
 
     for _ in 0..10 {
-        dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+        dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() }).await?;
     }
 
     Ok(())
@@ -88,7 +88,7 @@ async fn test_dag_with_only_source_tasks() -> DagResult<()> {
         .map(|i| dag.add_task(task_fn::<(), _, _>(move |_: ()| i)))
         .collect();
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() }).await?;
 
     for (i, task) in tasks.into_iter().enumerate() {
         assert_eq!(dag.get(task)?, i);
@@ -114,7 +114,7 @@ async fn test_single_self_contained_stateful_task() -> DagResult<()> {
     let dag = DagRunner::new();
     let task = dag.add_task(Counter { value: 21 });
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() }).await?;
 
     assert_eq!(dag.get(task)?, 42);
     Ok(())
@@ -128,11 +128,11 @@ async fn test_alternating_empty_and_filled_dag_runs() -> DagResult<()> {
 
         if i % 2 == 0 {
             // Empty DAG
-            dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+            dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() }).await?;
         } else {
             // DAG with a task
             let task = dag.add_task(task_fn::<(), _, _>(move |_: ()| i));
-            dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+            dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() }).await?;
             assert_eq!(dag.get(task)?, i);
         }
     }
@@ -152,7 +152,7 @@ async fn test_dag_with_never_type_simulation() -> DagResult<()> {
     // This task completes immediately but returns a Result containing "never" type
     let task = dag.add_task(task_fn::<(), _, _>(|_: ()| Result::<i32, Never>::Ok(42)));
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() }).await?;
 
     assert_eq!(dag.get(task)?, Ok(42));
     Ok(())
@@ -175,7 +175,7 @@ async fn test_minimal_task_with_minimal_async_work() -> DagResult<()> {
 
     let task = dag.add_task(YieldTask);
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() }).await?;
 
     assert_eq!(dag.get(task)?, 1337);
     Ok(())