Depend on futures-util instead of futures

tests/patterns/butterfly.rs

@@ -2,7 +2,7 @@
 
 use crate::common::task_fn;
 use dagx::{DagResult, DagRunner, TaskHandle};
-use futures::FutureExt;
+
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::Arc;
 
@@ -52,7 +52,8 @@ async fn test_butterfly_network() -> DagResult<()> {
             .depends_on((&layer1[3], &layer1[7])),
     ];
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+        .await?;
 
     // Verify some outputs exist
     for task in &layer2 {
@@ -107,7 +108,8 @@ async fn test_recursive_butterfly() -> DagResult<()> {
 
     let outputs = build_butterfly(&dag, inputs);
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+        .await?;
 
     assert_eq!(outputs.len(), 4);
     for output in outputs {
@@ -158,7 +160,8 @@ async fn test_benes_network() -> DagResult<()> {
             .depends_on((&stage1[1], &stage1[3])),
     ];
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+        .await?;
 
     for output in outputs {
         let _ = dag.get(output)?;
@@ -212,7 +215,8 @@ async fn test_shuffle_exchange_network() -> 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!(counter.load(Ordering::Relaxed), 8);
 

tests/patterns/complex.rs

@@ -2,7 +2,7 @@
 
 use crate::common::task_fn;
 use dagx::{DagResult, DagRunner, TaskHandle};
-use futures::FutureExt;
+
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::Arc;
 
@@ -60,7 +60,8 @@ async fn test_workflow_with_conditional_paths() -> DagResult<()> {
         }))
         .depends_on(combine);
 
-    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(process)?, 84);
     let result = dag.get(final_result)?;
@@ -147,7 +148,8 @@ async fn test_map_reduce_pattern() -> DagResult<()> {
         ))
         .depends_on((&reducers[0], &reducers[1], &reducers[2], &reducers[3]));
 
-    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 > 0);
@@ -198,7 +200,8 @@ async fn test_pipeline_with_feedback() -> DagResult<()> {
         }))
         .depends_on(stage3);
 
-    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(stage1)?, 2);
     assert_eq!(dag.get(stage3)?, 12);
@@ -244,7 +247,8 @@ async fn test_scatter_gather_pattern() -> DagResult<()> {
         ))
         .depends_on((&workers[0], &workers[1], &workers[2], &workers[3]));
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+        .await?;
 
     // Sum of 10+20+30+40+50+60+70+80 = 360
     assert_eq!(dag.get(gather)?, 360);
@@ -323,7 +327,8 @@ async fn test_fork_join_with_barriers() -> DagResult<()> {
         }))
         .depends_on(barrier);
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+        .await?;
 
     let _ = dag.get(join)?;
     assert_eq!(phase_counter.load(Ordering::SeqCst), 2);

tests/patterns/grid.rs

@@ -2,7 +2,6 @@
 
 use crate::common::task_fn;
 use dagx::{DagResult, DagRunner};
-use futures::FutureExt;
 
 #[tokio::test]
 async fn test_2d_grid_pattern() -> DagResult<()> {
@@ -37,7 +36,8 @@ async fn test_2d_grid_pattern() -> DagResult<()> {
         }
     }
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+        .await?;
 
     // Check corner values
     let bottom_right = dag.get(grid[3][3].as_ref().unwrap())?;
@@ -102,7 +102,8 @@ async fn test_3d_grid_pattern() -> DagResult<()> {
         }
     }
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+        .await?;
 
     // Check that all cells have values
     for row in &grid {
@@ -176,7 +177,8 @@ async fn test_hexagonal_grid() -> DagResult<()> {
         hex_grid.insert((q, r), task);
     }
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+        .await?;
 
     // Verify center and some ring values
     assert_eq!(dag.get(hex_grid.get(&(0, 0)).unwrap())?, 100);
@@ -225,7 +227,8 @@ async fn test_toroidal_grid() -> DagResult<()> {
         }
     }
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+        .await?;
 
     // Verify all torus tasks completed
     for task in torus_tasks {

tests/patterns/tree.rs

@@ -2,7 +2,6 @@
 
 use crate::common::task_fn;
 use dagx::{DagResult, DagRunner, TaskHandle};
-use futures::FutureExt;
 
 #[tokio::test]
 async fn test_binary_tree_reduction() -> DagResult<()> {
@@ -36,7 +35,8 @@ async fn test_binary_tree_reduction() -> DagResult<()> {
 
     let root = current_level[0];
 
-    dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
+    dag.run(|fut| async move { tokio::spawn(fut).await.unwrap() })
+        .await?;
 
     // Sum of powers of 2 from 0 to 7: 1+2+4+8+16+32+64+128 = 255
     assert_eq!(dag.get(root)?, 255);
@@ -67,7 +67,8 @@ async fn test_n_ary_tree() -> DagResult<()> {
 
     let root = build_tree(&dag, 3, 1);
 
-    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(root)?;
     assert!(result > 0);
@@ -114,7 +115,8 @@ async fn test_unbalanced_tree() -> DagResult<()> {
         .add_task(task_fn::<(i32, i32), _, _>(|(a, b): (&i32, &i32)| a * b))
         .depends_on((&a, &b));
 
-    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(f)?, 1);
     assert_eq!(dag.get(c)?, 2);
@@ -166,7 +168,8 @@ async fn test_trie_like_structure() -> DagResult<()> {
         .add_task(task_fn::<String, _, _>(|v: &String| format!("{}/log", v)))
         .depends_on(var);
 
-    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(usr_bin)?, "root/usr/bin");
     assert_eq!(dag.get(usr_lib)?, "root/usr/lib");
@@ -221,7 +224,8 @@ async fn test_balanced_k_ary_tree() -> DagResult<()> {
 
     let root = create_balanced_tree(&dag, DEPTH, K, 0);
 
-    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(root)?;
     assert!(result > 0);
@@ -268,7 +272,8 @@ async fn test_merkle_tree_pattern() -> DagResult<()> {
 
     let root_hash = current_level[0];
 
-    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(root_hash)?;
     assert!(result.starts_with("hash"));