Fix CI

benches/comparisons/deep_chain.rs

@@ -18,14 +18,14 @@ pub fn bench_deep_chain(c: &mut Criterion) {
 
                 let dag = DagRunner::new();
 
-                let first: TaskHandle<_> = dag.add_task(task_fn::<(), _, _>(|_: ()| { 0 })).into();
+                let first: TaskHandle<_> = dag.add_task(task_fn::<(), _, _>(|_: ()| 0)).into();
                 let mut prev = dag
-                    .add_task(task_fn::<i32, _, _>(|&x: &i32| { x + 1 }))
+                    .add_task(task_fn::<i32, _, _>(|&x: &i32| x + 1))
                     .depends_on(first);
 
                 for i in 2..100 {
                     prev = dag
-                        .add_task(task_fn::<i32, _, _>(move |&x: &i32| { x + i }))
+                        .add_task(task_fn::<i32, _, _>(move |&x: &i32| x + i))
                         .depends_on(prev);
                 }
 

benches/comparisons/etl_pipeline.rs

@@ -25,19 +25,19 @@ pub fn bench_etl_pipeline(c: &mut Criterion) {
                 // Transform each source
                 let transform1 = dag
                     .add_task(task_fn::<Vec<_>, _, _>(|data: &Vec<i32>| {
-                        data.into_iter().map(|x| x * 2).collect::<Vec<_>>()
+                        data.iter().map(|x| x * 2).collect::<Vec<_>>()
                     }))
                     .depends_on(source1);
 
                 let transform2 = dag
                     .add_task(task_fn::<Vec<_>, _, _>(|data: &Vec<i32>| {
-                        data.into_iter().map(|x| x * 2).collect::<Vec<_>>()
+                        data.iter().map(|x| x * 2).collect::<Vec<_>>()
                     }))
                     .depends_on(source2);
 
                 let transform3 = dag
                     .add_task(task_fn::<Vec<_>, _, _>(|data: &Vec<i32>| {
-                        data.into_iter().map(|x| x * 2).collect::<Vec<_>>()
+                        data.iter().map(|x| x * 2).collect::<Vec<_>>()
                     }))
                     .depends_on(source3);
 
@@ -66,7 +66,7 @@ pub fn bench_etl_pipeline(c: &mut Criterion) {
                 // Load (compute sum)
                 let load = dag
                     .add_task(task_fn::<Vec<_>, _, _>(|data: &Vec<i32>| {
-                        data.into_iter().sum::<i32>()
+                        data.iter().sum::<i32>()
                     }))
                     .depends_on(validate);
 

benches/comparisons/large_scale.rs

@@ -19,7 +19,7 @@ pub fn bench_large_scale(c: &mut Criterion) {
 
                 let dag = DagRunner::new();
                 for i in 0..10_000 {
-                    dag.add_task(task_fn::<(), _, _>(move |_: ()| { i * 2 }));
+                    dag.add_task(task_fn::<(), _, _>(move |_: ()| i * 2));
                 }
 
                 dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))

benches/comparisons/linear_pipeline.rs

@@ -17,18 +17,18 @@ pub fn bench_linear_pipeline(c: &mut Criterion) {
 
                 let dag = DagRunner::new();
 
-                let a = dag.add_task(task_fn::<(), _, _>(|_: ()| { 1 }));
+                let a = dag.add_task(task_fn::<(), _, _>(|_: ()| 1));
                 let b = dag
-                    .add_task(task_fn::<i32, _, _>(|&x: &i32| { x + 1 }))
+                    .add_task(task_fn::<i32, _, _>(|&x: &i32| x + 1))
                     .depends_on(a);
                 let c = dag
-                    .add_task(task_fn::<i32, _, _>(|&x: &i32| { x * 2 }))
+                    .add_task(task_fn::<i32, _, _>(|&x: &i32| x * 2))
                     .depends_on(b);
                 let d = dag
-                    .add_task(task_fn::<i32, _, _>(|&x: &i32| { x - 1 }))
+                    .add_task(task_fn::<i32, _, _>(|&x: &i32| x - 1))
                     .depends_on(c);
                 let e = dag
-                    .add_task(task_fn::<i32, _, _>(|&x: &i32| { x * 3 }))
+                    .add_task(task_fn::<i32, _, _>(|&x: &i32| x * 3))
                     .depends_on(d);
 
                 dag.run(|fut| tokio::spawn(fut).map(Result::unwrap))

benches/comparisons/wide_fanout.rs

@@ -17,11 +17,11 @@ pub fn bench_wide_fanout(c: &mut Criterion) {
                 use dagx::{task_fn, DagRunner};
 
                 let dag = DagRunner::new();
-                let source: TaskHandle<_> = dag.add_task(task_fn::<(), _, _>(|_: ()| { 42 })).into();
+                let source: TaskHandle<_> = dag.add_task(task_fn::<(), _, _>(|_: ()| 42)).into();
 
                 // Create 100 tasks that all depend on source
                 for i in 0..100 {
-                    dag.add_task(task_fn::<i32, _, _>(move |&x: &i32| { x + i }))
+                    dag.add_task(task_fn::<i32, _, _>(move |&x: &i32| x + i))
                         .depends_on(source);
                 }