Don't require an explicit return type in the task macro

tests/arc_tests.rs

@@ -9,7 +9,7 @@
 //!
 //! These tests serve as both validation and documentation for proper Arc usage.
 
-use dagx::{task, DagRunner, Task};
+use dagx::{task, DagRunner};
 use futures::FutureExt;
 use std::collections::{HashMap, HashSet};
 use std::sync::Arc;

tests/boundaries/zero_tasks.rs

@@ -1,7 +1,7 @@
 //! Tests for empty DAGs and minimal task configurations
 
 use crate::common::task_fn;
-use dagx::{task, DagResult, DagRunner, Task};
+use dagx::{task, DagResult, DagRunner};
 use futures::FutureExt;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::Arc;

tests/common/mod.rs

@@ -7,7 +7,7 @@ pub use dagx::task_fn;
 // Re-export commonly used test structs
 #[allow(dead_code)]
 pub mod tasks {
-    use dagx::{task, Task};
+    use dagx::task;
 
     // Simple seed task with mutable state
     pub struct Seed {

tests/custom_type_test.rs

@@ -1,5 +1,5 @@
 // Test that custom types work without any trait implementations
-use dagx::{task, DagRunner, Task};
+use dagx::{task, DagRunner};
 use futures::FutureExt;
 
 #[derive(Clone, Debug, PartialEq)]

tests/cycle_prevention.rs

@@ -3,7 +3,7 @@
 //! These tests show that even if you try to create cycles, the Rust compiler
 //! prevents it through the type-state pattern.
 
-use dagx::{task, DagRunner, Task, TaskHandle};
+use dagx::{task, DagRunner, TaskHandle};
 use futures::FutureExt;
 
 /// Demonstrates that TaskBuilder is consumed by depends_on,

tests/parallelism/timing.rs

@@ -1,7 +1,8 @@
 //! Tests for timing and speedup verification
 
 use crate::common::task_fn;
-use dagx::{DagResult, DagRunner, Task};
+
+use dagx::{DagResult, DagRunner};
 use futures::FutureExt;
 use std::sync::Arc;
 use std::sync::Mutex;

tests/patterns/grid.rs

@@ -12,6 +12,7 @@ async fn test_2d_grid_pattern() -> DagResult<()> {
     let mut grid: Vec<Vec<Option<dagx::TaskHandle<i32>>>> = vec![vec![None; 4]; 4];
 
     // Initialize first row and column
+    #[allow(clippy::needless_range_loop)]
     for i in 0..4 {
         let task = dag.add_task(task_fn(move |_: ()| async move { i as i32 }));
         grid[0][i] = Some((&task).into());

tests/runtimes/async_std.rs

@@ -1,7 +1,7 @@
 //! Runtime compatibility tests for async-std
 
 use crate::common::task_fn;
-use dagx::{DagRunner, Task};
+use dagx::DagRunner;
 
 struct Value(i32);
 #[dagx::task]
@@ -27,7 +27,7 @@ async fn test_basic_dag_async_std() {
     let y = dag.add_task(Value(3));
     let sum = dag.add_task(Add).depends_on((&x, &y));
 
-    dag.run(|fut| async_std::task::spawn(fut)).await.unwrap();
+    dag.run(async_std::task::spawn).await.unwrap();
 
     assert_eq!(dag.get(sum).unwrap(), 5);
 }
@@ -40,7 +40,7 @@ async fn test_parallel_execution_async_std() {
         .map(|i| dag.add_task(task_fn(move |_: ()| async move { i * 2 })))
         .collect();
 
-    dag.run(|fut| async_std::task::spawn(fut)).await.unwrap();
+    dag.run(async_std::task::spawn).await.unwrap();
 
     for (i, task) in tasks.iter().enumerate() {
         assert_eq!(dag.get(task).unwrap(), i * 2);
@@ -58,7 +58,7 @@ async fn test_complex_dependencies_async_std() {
         .add_task(task_fn(|x: i32| async move { x * 2 }))
         .depends_on(sum);
 
-    dag.run(|fut| async_std::task::spawn(fut)).await.unwrap();
+    dag.run(async_std::task::spawn).await.unwrap();
 
     assert_eq!(dag.get(double).unwrap(), 60);
 }

tests/runtimes/compatibility.rs

@@ -1,6 +1,6 @@
 //! Runtime integration tests - verify dagx works correctly across different runtimes
 
-use dagx::{DagResult, DagRunner, Task};
+use dagx::{DagResult, DagRunner};
 use futures::FutureExt;
 
 struct Value(i32);

tests/runtimes/quirky.rs

@@ -444,8 +444,6 @@ fn test_futures_executor_multi_pool() {
 
 #[test]
 fn test_sync_tasks_on_async_executor() {
-    use dagx::Task;
-
     struct SyncAdd;
 
     #[dagx::task]
@@ -473,8 +471,6 @@ fn test_sync_tasks_on_async_executor() {
 
 #[test]
 fn test_sync_tasks_on_pollster() {
-    use dagx::Task;
-
     struct SyncDouble;
 
     #[dagx::task]

tests/runtimes/smol.rs

@@ -1,7 +1,7 @@
 //! Runtime compatibility tests for smol
 
 use crate::common::task_fn;
-use dagx::{DagRunner, Task};
+use dagx::DagRunner;
 
 struct Value(i32);
 #[dagx::task]
@@ -28,7 +28,7 @@ fn test_basic_dag_smol() {
         let y = dag.add_task(Value(3));
         let sum = dag.add_task(Add).depends_on((&x, &y));
 
-        dag.run(|fut| smol::spawn(fut)).await.unwrap();
+        dag.run(smol::spawn).await.unwrap();
 
         assert_eq!(dag.get(sum).unwrap(), 5);
     });
@@ -43,7 +43,7 @@ fn test_parallel_execution_smol() {
             .map(|i| dag.add_task(task_fn(move |_: ()| async move { i * 2 })))
             .collect();
 
-        dag.run(|fut| smol::spawn(fut)).await.unwrap();
+        dag.run(smol::spawn).await.unwrap();
 
         for (i, task) in tasks.iter().enumerate() {
             assert_eq!(dag.get(task).unwrap(), i * 2);
@@ -63,7 +63,7 @@ fn test_complex_dependencies_smol() {
             .add_task(task_fn(|x: i32| async move { x * 2 }))
             .depends_on(sum);
 
-        dag.run(|fut| smol::spawn(fut)).await.unwrap();
+        dag.run(smol::spawn).await.unwrap();
 
         assert_eq!(dag.get(double).unwrap(), 60);
     });

tests/tracing/with_tracing.rs

@@ -1,6 +1,6 @@
 //! Tests with tracing feature enabled
 
-use dagx::{task, DagRunner, Task};
+use dagx::{task, DagRunner};
 use futures::FutureExt;
 use tracing_subscriber::{fmt, EnvFilter};
 

tests/tracing/without_tracing.rs

@@ -1,6 +1,6 @@
 //! Tests that the library works correctly without tracing feature
 
-use dagx::{task, DagRunner, Task};
+use dagx::{task, DagRunner};
 use futures::FutureExt;
 
 struct Value(i32);