Update tests, examples, benches

benches/patterns/breakdown.rs

@@ -14,7 +14,7 @@ pub fn bench_10k_breakdown(c: &mut Criterion) {
         b.iter(|| {
             let dag = DagRunner::new();
             for i in 0..10_000 {
-                dag.add_task(task_fn(move |_: ()| async move { i }));
+                dag.add_task(task_fn::<(), _, _>(move |_: ()| { i }));
             }
         });
     });
@@ -25,7 +25,7 @@ pub fn bench_10k_breakdown(c: &mut Criterion) {
             rt.block_on(async {
                 let dag = DagRunner::new();
                 for i in 0..10_000 {
-                    dag.add_task(task_fn(move |_: ()| async move { i }));
+                    dag.add_task(task_fn::<(), _, _>(move |_: ()| { i }));
                 }
                 dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))
                     .await
@@ -39,7 +39,7 @@ pub fn bench_10k_breakdown(c: &mut Criterion) {
         // Pre-build the DAG outside the measurement
         let dag = DagRunner::new();
         for i in 0..10_000 {
-            dag.add_task(task_fn(move |_: ()| async move { i }));
+            dag.add_task(task_fn::<(), _, _>(move |_: ()| { i }));
         }
 
         b.iter(|| {

benches/patterns/diamond.rs

@@ -14,16 +14,16 @@ pub fn bench_diamond(c: &mut Criterion) {
 
                 for i in 0..50 {
                     let source: TaskHandle<_> =
-                        dag.add_task(task_fn(move |_: ()| async move { i })).into();
+                        dag.add_task(task_fn::<(), _, _>(move |_: ()| i)).into();
 
                     let left = dag
-                        .add_task(task_fn(|x: i32| async move { x * 2 }))
+                        .add_task(task_fn::<i32, _, _>(|&x: &i32| x * 2))
                         .depends_on(source);
                     let right = dag
-                        .add_task(task_fn(|x: i32| async move { x * 3 }))
+                        .add_task(task_fn::<i32, _, _>(|&x: &i32| x * 3))
                         .depends_on(source);
 
-                    dag.add_task(task_fn(|(l, r): (i32, i32)| async move { l + r }))
+                    dag.add_task(task_fn::<(i32, i32), _, _>(|(l, r): (&i32, &i32)| l + r))
                         .depends_on((&left, &right));
                 }
 

benches/patterns/fanout.rs

@@ -12,10 +12,10 @@ pub fn bench_fanout(c: &mut Criterion) {
         b.iter(|| {
             rt.block_on(async {
                 let dag = DagRunner::new();
-                let source: TaskHandle<_> = dag.add_task(task_fn(|_: ()| async { 42 })).into();
+                let source: TaskHandle<_> = dag.add_task(task_fn::<(), _, _>(|_: ()| 42)).into();
 
                 for i in 0..100 {
-                    dag.add_task(task_fn(move |x: i32| async move { x + i }))
+                    dag.add_task(task_fn::<i32, _, _>(move |&x: &i32| x + i))
                         .depends_on(source);
                 }
 
@@ -32,14 +32,14 @@ pub fn bench_fanout(c: &mut Criterion) {
             rt.block_on(async {
                 let dag = DagRunner::new();
                 let source: TaskHandle<_> = dag
-                    .add_task(task_fn(|_: ()| async {
+                    .add_task(task_fn::<(), _, _>(|_: ()| {
                         // Create 1000 strings - framework wraps in Arc automatically
                         (0..1000).map(|i| format!("Item {}", i)).collect::<Vec<_>>()
                     }))
                     .into();
 
                 for i in 0..100 {
-                    dag.add_task(task_fn(move |data: Vec<String>| async move {
+                    dag.add_task(task_fn::<Vec<_>, _, _>(move |data: &Vec<String>| {
                         // Each consumer gets data extracted from Arc
                         data.iter().filter(|s| s.contains(&i.to_string())).count()
                     }))
@@ -63,11 +63,12 @@ pub fn bench_fanout(c: &mut Criterion) {
 
                 // Source produces a simple Copy type (usize)
                 // Framework wraps in Arc<usize> internally
-                let source: TaskHandle<_> = dag.add_task(task_fn(|_: ()| async { 42usize })).into();
+                let source: TaskHandle<_> =
+                    dag.add_task(task_fn::<(), _, _>(|_: ()| 42usize)).into();
 
                 // 100 dependents - Arc overhead visible on Copy types
                 for i in 0..100 {
-                    dag.add_task(task_fn(move |x: usize| async move { x + i }))
+                    dag.add_task(task_fn::<usize, _, _>(move |x: &usize| x + i))
                         .depends_on(source);
                 }