Update tests, examples, benches

tests/dependencies/single.rs

@@ -8,9 +8,9 @@ use futures::FutureExt;
 async fn test_single_dependency() -> DagResult<()> {
     let dag = DagRunner::new();
 
-    let source = dag.add_task(task_fn(|_: ()| async { 42 }));
+    let source = dag.add_task(task_fn::<(), _, _>(|_: ()| 42));
     let dependent = dag
-        .add_task(task_fn(|x: i32| async move { x + 1 }))
+        .add_task(task_fn::<i32, _, _>(|&x: &i32| x + 1))
         .depends_on(source);
 
     dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
@@ -25,21 +25,23 @@ async fn test_dependency_data_flow() -> DagResult<()> {
     let dag = DagRunner::new();
 
     let source: TaskHandle<_> = dag
-        .add_task(task_fn(|_: ()| async { vec![1, 2, 3, 4, 5] }))
+        .add_task(task_fn::<(), _, _>(|_: ()| vec![1, 2, 3, 4, 5]))
         .into();
 
     let sum = dag
-        .add_task(task_fn(|v: Vec<i32>| async move { v.iter().sum::<i32>() }))
+        .add_task(task_fn::<Vec<_>, _, _>(|v: &Vec<i32>| {
+            v.iter().sum::<i32>()
+        }))
         .depends_on(source);
 
     let product = dag
-        .add_task(task_fn(
-            |v: Vec<i32>| async move { v.iter().product::<i32>() },
-        ))
+        .add_task(task_fn::<Vec<_>, _, _>(|v: &Vec<i32>| {
+            v.iter().product::<i32>()
+        }))
         .depends_on(source);
 
     let final_result = dag
-        .add_task(task_fn(|(s, p): (i32, i32)| async move { s + p }))
+        .add_task(task_fn::<(i32, i32), _, _>(|(s, p): (&i32, &i32)| s + p))
         .depends_on((&sum, &product));
 
     dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
@@ -56,14 +58,14 @@ async fn test_dependencies_with_different_types() -> DagResult<()> {
     // Test that dependencies with different types work correctly
     let dag = DagRunner::new();
 
-    let int_source = dag.add_task(task_fn(|_: ()| async { 42 }));
-    let string_source = dag.add_task(task_fn(|_: ()| async { "hello".to_string() }));
-    let bool_source = dag.add_task(task_fn(|_: ()| async { true }));
+    let int_source = dag.add_task(task_fn::<(), _, _>(|_: ()| 42));
+    let string_source = dag.add_task(task_fn::<(), _, _>(|_: ()| "hello".to_string()));
+    let bool_source = dag.add_task(task_fn::<(), _, _>(|_: ()| true));
 
     let combined = dag
-        .add_task(task_fn(|(i, s, b): (i32, String, bool)| async move {
-            format!("{}: {} ({})", s, i, b)
-        }))
+        .add_task(task_fn::<(i32, String, bool), _, _>(
+            |(i, s, b): (&i32, &String, &bool)| format!("{}: {} ({})", s, i, b),
+        ))
         .depends_on((int_source, string_source, bool_source));
 
     dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;
@@ -77,12 +79,12 @@ async fn test_shared_dependencies() -> DagResult<()> {
     // Test that a single node can be a dependency for multiple downstream nodes
     let dag = DagRunner::new();
 
-    let shared: TaskHandle<_> = dag.add_task(task_fn(|_: ()| async { 42 })).into();
+    let shared: TaskHandle<_> = dag.add_task(task_fn::<(), _, _>(|_: ()| 42)).into();
 
     // Create 10 tasks that all depend on the shared node
     let dependents: Vec<_> = (0..10)
         .map(|i| {
-            dag.add_task(task_fn(move |x: i32| async move { x * (i + 1) }))
+            dag.add_task(task_fn::<i32, _, _>(move |&x: &i32| x * (i + 1)))
                 .depends_on(shared)
         })
         .collect();
@@ -103,7 +105,7 @@ async fn test_multiple_source_nodes() -> DagResult<()> {
     let dag = DagRunner::new();
 
     let sources: Vec<_> = (0..20)
-        .map(|i| dag.add_task(task_fn(move |_: ()| async move { i * 10 })))
+        .map(|i| dag.add_task(task_fn::<(), _, _>(move |_: ()| i * 10)))
         .collect();
 
     dag.run(|fut| tokio::spawn(fut).map(Result::unwrap)).await?;