Repository: jorgecarleitao/arrow2
Pull request #1351 (2023-01-04 14:49:43)

Fix incorrect downcast in `estimated_size_bytes`
Looks like this might have been a copy-and-paste error?

Added a unit-test for fixed_size_list as well.

ritchie46: Thanks you @jleibs :+1: 

Patch:
diff --git a/benches/aggregate.rs b/benches/aggregate.rs
index f157550d15..ac5002d31e 100644
--- a/benches/aggregate.rs
+++ b/benches/aggregate.rs
@@ -17,41 +17,41 @@ fn add_benchmark(c: &mut Criterion) {
         let size = 2usize.pow(log2_size);
         let arr_a = create_primitive_array::<f32>(size, 0.0);
 
-        c.bench_function(&format!("sum 2^{} f32", log2_size), |b| {
+        c.bench_function(&format!("sum 2^{log2_size} f32"), |b| {
             b.iter(|| bench_sum(&arr_a))
         });
-        c.bench_function(&format!("min 2^{} f32", log2_size), |b| {
+        c.bench_function(&format!("min 2^{log2_size} f32"), |b| {
             b.iter(|| bench_min(&arr_a))
         });
 
         let arr_a = create_primitive_array::<i32>(size, 0.0);
 
-        c.bench_function(&format!("sum 2^{} i32", log2_size), |b| {
+        c.bench_function(&format!("sum 2^{log2_size} i32"), |b| {
             b.iter(|| bench_sum(&arr_a))
         });
-        c.bench_function(&format!("min 2^{} i32", log2_size), |b| {
+        c.bench_function(&format!("min 2^{log2_size} i32"), |b| {
             b.iter(|| bench_min(&arr_a))
         });
 
         let arr_a = create_primitive_array::<f32>(size, 0.1);
 
-        c.bench_function(&format!("sum null 2^{} f32", log2_size), |b| {
+        c.bench_function(&format!("sum null 2^{log2_size} f32"), |b| {
             b.iter(|| bench_sum(&arr_a))
         });
 
-        c.bench_function(&format!("min null 2^{} f32", log2_size), |b| {
+        c.bench_function(&format!("min null 2^{log2_size} f32"), |b| {
             b.iter(|| bench_min(&arr_a))
         });
 
         let arr_a = create_string_array::<i32>(1, size, 0.0, 0);
 
-        c.bench_function(&format!("min 2^{} utf8", log2_size), |b| {
+        c.bench_function(&format!("min 2^{log2_size} utf8"), |b| {
             b.iter(|| bench_min(&arr_a))
         });
 
         let arr_a = create_string_array::<i32>(1, size, 0.1, 0);
 
-        c.bench_function(&format!("min null 2^{} utf8", log2_size), |b| {
+        c.bench_function(&format!("min null 2^{log2_size} utf8"), |b| {
             b.iter(|| bench_min(&arr_a))
         });
     });
diff --git a/benches/arithmetic_kernels.rs b/benches/arithmetic_kernels.rs
index c96b3ea288..950a08b10f 100644
--- a/benches/arithmetic_kernels.rs
+++ b/benches/arithmetic_kernels.rs
@@ -27,16 +27,16 @@ fn add_benchmark(c: &mut Criterion) {
         let arr_a = create_primitive_array_with_seed::<u64>(size, 0.0, 43);
         let arr_b = create_primitive_array_with_seed::<u64>(size, 0.0, 42);
 
-        c.bench_function(&format!("divide_scalar 2^{}", log2_size), |b| {
+        c.bench_function(&format!("divide_scalar 2^{log2_size}"), |b| {
             // 4 is a very fast optimizable divisor
             b.iter(|| bench_div_scalar(&arr_a, &4))
         });
-        c.bench_function(&format!("divide_scalar prime 2^{}", log2_size), |b| {
+        c.bench_function(&format!("divide_scalar prime 2^{log2_size}"), |b| {
             // large prime number that is probably harder to simplify
             b.iter(|| bench_div_scalar(&arr_a, &524287))
         });
 
-        c.bench_function(&format!("add 2^{}", log2_size), |b| {
+        c.bench_function(&format!("add 2^{log2_size}"), |b| {
             b.iter(|| bench_add(&arr_a, &arr_b))
         });
     });
diff --git a/benches/assign_ops.rs b/benches/assign_ops.rs
index 7b169ec42d..5c190e43c5 100644
--- a/benches/assign_ops.rs
+++ b/benches/assign_ops.rs
@@ -11,7 +11,7 @@ fn add_benchmark(c: &mut Criterion) {
         let size = 2usize.pow(log2_size);
 
         let mut arr_a = create_primitive_array::<f32>(size, 0.2);
-        c.bench_function(&format!("apply_mul 2^{}", log2_size), |b| {
+        c.bench_function(&format!("apply_mul 2^{log2_size}"), |b| {
             b.iter(|| {
                 unary(criterion::black_box(&mut arr_a), |x| x * 1.01);
                 assert!(!arr_a.value(10).is_nan());
@@ -19,7 +19,7 @@ fn add_benchmark(c: &mut Criterion) {
         });
 
         let arr_a = create_primitive_array::<f32>(size, 0.2);
-        c.bench_function(&format!("mul 2^{}", log2_size), |b| {
+        c.bench_function(&format!("mul 2^{log2_size}"), |b| {
             b.iter(|| {
                 let a = mul_scalar(criterion::black_box(&arr_a), &1.01f32);
                 assert!(!a.value(10).is_nan());
@@ -31,7 +31,7 @@ fn add_benchmark(c: &mut Criterion) {
         // convert to be close to 1.01
         unary(&mut arr_b, |x| 1.01 + x / 20.0);
 
-        c.bench_function(&format!("apply_mul null 2^{}", log2_size), |b| {
+        c.bench_function(&format!("apply_mul null 2^{log2_size}"), |b| {
             b.iter(|| {
                 binary(criterion::black_box(&mut arr_a), &arr_b, |x, y| x * y);
                 assert!(!arr_a.value(10).is_nan());
@@ -39,7 +39,7 @@ fn add_benchmark(c: &mut Criterion) {
         });
 
         let arr_a = create_primitive_array::<f32>(size, 0.2);
-        c.bench_function(&format!("mul null 2^{}", log2_size), |b| {
+        c.bench_function(&format!("mul null 2^{log2_size}"), |b| {
             b.iter(|| {
                 let a = mul(criterion::black_box(&arr_a), &arr_b);
                 assert!(!a.value(10).is_nan());
diff --git a/benches/bitmap.rs b/benches/bitmap.rs
index 4f77bb3ac8..5fde7fca77 100644
--- a/benches/bitmap.rs
+++ b/benches/bitmap.rs
@@ -10,7 +10,7 @@ fn add_benchmark(c: &mut Criterion) {
 
         let bitmap2 = Bitmap::from_iter((0..size).into_iter().map(|x| x % 3 == 0));
 
-        c.bench_function(&format!("bitmap extend aligned 2^{}", log2_size), |b| {
+        c.bench_function(&format!("bitmap extend aligned 2^{log2_size}"), |b| {
             let mut bitmap1 = MutableBitmap::new();
             b.iter(|| {
                 bitmap1.extend_from_bitmap(&bitmap2);
@@ -18,7 +18,7 @@ fn add_benchmark(c: &mut Criterion) {
             })
         });
 
-        c.bench_function(&format!("bitmap extend unaligned 2^{}", log2_size), |b| {
+        c.bench_function(&format!("bitmap extend unaligned 2^{log2_size}"), |b| {
             let mut bitmap1 = MutableBitmap::with_capacity(1);
             b.iter(|| {
                 bitmap1.push(true);
@@ -28,7 +28,7 @@ fn add_benchmark(c: &mut Criterion) {
         });
 
         c.bench_function(
-            &format!("bitmap extend_constant aligned 2^{}", log2_size),
+            &format!("bitmap extend_constant aligned 2^{log2_size}"),
             |b| {
                 let mut bitmap1 = MutableBitmap::new();
                 b.iter(|| {
@@ -39,7 +39,7 @@ fn add_benchmark(c: &mut Criterion) {
         );
 
         c.bench_function(
-            &format!("bitmap extend_constant unaligned 2^{}", log2_size),
+            &format!("bitmap extend_constant unaligned 2^{log2_size}"),
             |b| {
                 let mut bitmap1 = MutableBitmap::with_capacity(1);
                 b.iter(|| {
@@ -54,14 +54,14 @@ fn add_benchmark(c: &mut Criterion) {
             .into_iter()
             .map(|x| x % 3 == 0)
             .collect::<Vec<_>>();
-        c.bench_function(&format!("bitmap from_trusted_len 2^{}", log2_size), |b| {
+        c.bench_function(&format!("bitmap from_trusted_len 2^{log2_size}"), |b| {
             b.iter(|| {
                 MutableBitmap::from_trusted_len_iter(iter.iter().copied());
             })
         });
 
         c.bench_function(
-            &format!("bitmap extend_from_trusted_len_iter 2^{}", log2_size),
+            &format!("bitmap extend_from_trusted_len_iter 2^{log2_size}"),
             |b| {
                 b.iter(|| {
                     let mut a = MutableBitmap::from(&[true]);
diff --git a/benches/bitmap_assign_ops.rs b/benches/bitmap_assign_ops.rs
index c962e8ed95..926be0a60e 100644
--- a/benches/bitmap_assign_ops.rs
+++ b/benches/bitmap_assign_ops.rs
@@ -8,7 +8,7 @@ fn add_benchmark(c: &mut Criterion) {
         let size = 2usize.pow(log2_size);
 
         let mut bitmap: MutableBitmap = (0..size).into_iter().map(|x| x % 3 == 0).collect();
-        c.bench_function(&format!("mutablebitmap not 2^{}", log2_size), |b| {
+        c.bench_function(&format!("mutablebitmap not 2^{log2_size}"), |b| {
             b.iter(|| {
                 unary_assign(criterion::black_box(&mut bitmap), |x: u64| !x);
                 assert!(!bitmap.is_empty());
@@ -16,7 +16,7 @@ fn add_benchmark(c: &mut Criterion) {
         });
 
         let bitmap: Bitmap = (0..size).into_iter().map(|x| x % 3 == 0).collect();
-        c.bench_function(&format!("bitmap not 2^{}", log2_size), |b| {
+        c.bench_function(&format!("bitmap not 2^{log2_size}"), |b| {
             b.iter(|| {
                 let r = !criterion::black_box(&bitmap);
                 assert!(!r.is_empty());
@@ -25,7 +25,7 @@ fn add_benchmark(c: &mut Criterion) {
 
         let mut lhs: MutableBitmap = (0..size).into_iter().map(|x| x % 3 == 0).collect();
         let rhs: Bitmap = (0..size).into_iter().map(|x| x % 4 == 0).collect();
-        c.bench_function(&format!("mutablebitmap and 2^{}", log2_size), |b| {
+        c.bench_function(&format!("mutablebitmap and 2^{log2_size}"), |b| {
             b.iter(|| {
                 binary_assign(criterion::black_box(&mut lhs), &rhs, |x: u64, y| x & y);
                 assert!(!bitmap.is_empty());
@@ -34,7 +34,7 @@ fn add_benchmark(c: &mut Criterion) {
 
         let lhs: Bitmap = (0..size).into_iter().map(|x| x % 3 == 0).collect();
         let rhs: Bitmap = (0..size).into_iter().map(|x| x % 4 == 0).collect();
-        c.bench_function(&format!("bitmap and 2^{}", log2_size), |b| {
+        c.bench_function(&format!("bitmap and 2^{log2_size}"), |b| {
             b.iter(|| {
                 let r = criterion::black_box(&lhs) & &rhs;
                 assert!(!r.is_empty());
diff --git a/benches/bitmap_ops.rs b/benches/bitmap_ops.rs
index dcd38661bf..f1fd06f195 100644
--- a/benches/bitmap_ops.rs
+++ b/benches/bitmap_ops.rs
@@ -12,7 +12,7 @@ fn add_benchmark(c: &mut Criterion) {
         let size = 2usize.pow(log2_size);
 
         let bitmap: Bitmap = (0..size).into_iter().map(|x| x % 3 == 0).collect();
-        c.bench_function(&format!("bitmap aligned not 2^{}", log2_size), |b| {
+        c.bench_function(&format!("bitmap aligned not 2^{log2_size}"), |b| {
             b.iter(|| {
                 let r = !&bitmap;
                 assert!(r.unset_bits() > 0);
@@ -23,7 +23,7 @@ fn add_benchmark(c: &mut Criterion) {
         let len = ((size as f64) * 0.85) as usize;
 
         c.bench_function(
-            &format!("bitmap count zeros 85% slice 2^{}", log2_size),
+            &format!("bitmap count zeros 85% slice 2^{log2_size}"),
             |b| {
                 b.iter(|| {
                     let r = bitmap.clone().slice(offset, len);
@@ -36,7 +36,7 @@ fn add_benchmark(c: &mut Criterion) {
         let len = ((size as f64) * 0.51) as usize;
 
         c.bench_function(
-            &format!("bitmap count zeros 51% slice 2^{}", log2_size),
+            &format!("bitmap count zeros 51% slice 2^{log2_size}"),
             |b| {
                 b.iter(|| {
                     let r = bitmap.clone().slice(offset, len);
@@ -46,7 +46,7 @@ fn add_benchmark(c: &mut Criterion) {
         );
 
         let bitmap1 = bitmap.clone().slice(1, size - 1);
-        c.bench_function(&format!("bitmap not 2^{}", log2_size), |b| {
+        c.bench_function(&format!("bitmap not 2^{log2_size}"), |b| {
             b.iter(|| {
                 let r = !&bitmap1;
                 assert!(r.unset_bits() > 0);
@@ -54,7 +54,7 @@ fn add_benchmark(c: &mut Criterion) {
         });
 
         let bitmap1: Bitmap = (0..size).into_iter().map(|x| x % 4 == 0).collect();
-        c.bench_function(&format!("bitmap aligned or 2^{}", log2_size), |b| {
+        c.bench_function(&format!("bitmap aligned or 2^{log2_size}"), |b| {
             b.iter(|| bench_arrow2(&bitmap, &bitmap1))
         });
     });
diff --git a/benches/bitwise.rs b/benches/bitwise.rs
index 4e1fc9f82d..704e32aac7 100644
--- a/benches/bitwise.rs
+++ b/benches/bitwise.rs
@@ -42,19 +42,19 @@ fn add_benchmark(c: &mut Criterion) {
         let arr_a = create_primitive_array_with_seed::<u64>(size, 0.0, 43);
         let arr_b = create_primitive_array_with_seed::<u64>(size, 0.0, 42);
 
-        c.bench_function(&format!("or 2^{}", log2_size), |b| {
+        c.bench_function(&format!("or 2^{log2_size}"), |b| {
             b.iter(|| bench_or(&arr_a, &arr_b))
         });
 
-        c.bench_function(&format!("xor 2^{}", log2_size), |b| {
+        c.bench_function(&format!("xor 2^{log2_size}"), |b| {
             b.iter(|| bench_xor(&arr_a, &arr_b))
         });
 
-        c.bench_function(&format!("and 2^{}", log2_size), |b| {
+        c.bench_function(&format!("and 2^{log2_size}"), |b| {
             b.iter(|| bench_and(&arr_a, &arr_b))
         });
 
-        c.bench_function(&format!("not 2^{}", log2_size), |b| {
+        c.bench_function(&format!("not 2^{log2_size}"), |b| {
             b.iter(|| bench_not(&arr_a))
         });
     });
diff --git a/benches/comparison_kernels.rs b/benches/comparison_kernels.rs
index 1371471d2c..cbea8f8f74 100644
--- a/benches/comparison_kernels.rs
+++ b/benches/comparison_kernels.rs
@@ -11,30 +11,30 @@ fn add_benchmark(c: &mut Criterion) {
         let arr_a = create_primitive_array_with_seed::<f32>(size, 0.0, 42);
         let arr_b = create_primitive_array_with_seed::<f32>(size, 0.0, 43);
 
-        c.bench_function(&format!("f32 2^{}", log2_size), |b| {
+        c.bench_function(&format!("f32 2^{log2_size}"), |b| {
             b.iter(|| eq(&arr_a, &arr_b))
         });
-        c.bench_function(&format!("f32 scalar 2^{}", log2_size), |b| {
+        c.bench_function(&format!("f32 scalar 2^{log2_size}"), |b| {
             b.iter(|| eq_scalar(&arr_a, &PrimitiveScalar::<f32>::from(Some(0.5))))
         });
 
         let arr_a = create_boolean_array(size, 0.0, 0.1);
         let arr_b = create_boolean_array(size, 0.0, 0.2);
 
-        c.bench_function(&format!("bool 2^{}", log2_size), |b| {
+        c.bench_function(&format!("bool 2^{log2_size}"), |b| {
             b.iter(|| eq(&arr_a, &arr_b))
         });
-        c.bench_function(&format!("bool scalar 2^{}", log2_size), |b| {
+        c.bench_function(&format!("bool scalar 2^{log2_size}"), |b| {
             b.iter(|| eq_scalar(&arr_a, &BooleanScalar::from(Some(false))))
         });
 
         let arr_a = create_string_array::<i32>(size, 4, 0.1, 42);
         let arr_b = create_string_array::<i32>(size, 4, 0.1, 43);
-        c.bench_function(&format!("utf8 2^{}", log2_size), |b| {
+        c.bench_function(&format!("utf8 2^{log2_size}"), |b| {
             b.iter(|| eq(&arr_a, &arr_b))
         });
 
-        c.bench_function(&format!("utf8 2^{}", log2_size), |b| {
+        c.bench_function(&format!("utf8 2^{log2_size}"), |b| {
             b.iter(|| eq_scalar(&arr_a, &Utf8Scalar::<i32>::from(Some("abc"))))
         });
     })
diff --git a/benches/concatenate.rs b/benches/concatenate.rs
index 7a6148f455..b2e3713d44 100644
--- a/benches/concatenate.rs
+++ b/benches/concatenate.rs
@@ -12,7 +12,7 @@ fn add_benchmark(c: &mut Criterion) {
         let array1 = create_primitive_array::<i32>(8, 0.5);
         let array2 = create_primitive_array::<i32>(size + 1, 0.5);
 
-        c.bench_function(&format!("int32 concat aligned 2^{}", log2_size), |b| {
+        c.bench_function(&format!("int32 concat aligned 2^{log2_size}"), |b| {
             b.iter(|| {
                 let _ = concatenate(&[&array1, &array2]);
             })
@@ -20,7 +20,7 @@ fn add_benchmark(c: &mut Criterion) {
 
         let array1 = create_primitive_array::<i32>(9, 0.5);
 
-        c.bench_function(&format!("int32 concat unaligned 2^{}", log2_size), |b| {
+        c.bench_function(&format!("int32 concat unaligned 2^{log2_size}"), |b| {
             b.iter(|| {
                 let _ = concatenate(&[&array1, &array2]);
             })
@@ -29,7 +29,7 @@ fn add_benchmark(c: &mut Criterion) {
         let array1 = create_boolean_array(8, 0.5, 0.5);
         let array2 = create_boolean_array(size + 1, 0.5, 0.5);
 
-        c.bench_function(&format!("boolean concat aligned 2^{}", log2_size), |b| {
+        c.bench_function(&format!("boolean concat aligned 2^{log2_size}"), |b| {
             b.iter(|| {
                 let _ = concatenate(&[&array1, &array2]);
             })
@@ -37,7 +37,7 @@ fn add_benchmark(c: &mut Criterion) {
 
         let array1 = create_boolean_array(9, 0.5, 0.5);
 
-        c.bench_function(&format!("boolean concat unaligned 2^{}", log2_size), |b| {
+        c.bench_function(&format!("boolean concat unaligned 2^{log2_size}"), |b| {
             b.iter(|| {
                 let _ = concatenate(&[&array1, &array2]);
             })
diff --git a/benches/count_zeros.rs b/benches/count_zeros.rs
index 069fa40315..38d1570d21 100644
--- a/benches/count_zeros.rs
+++ b/benches/count_zeros.rs
@@ -10,11 +10,11 @@ fn add_benchmark(c: &mut Criterion) {
             .map(|x| 0b01011011u8.rotate_left(x))
             .collect::<Vec<_>>();
 
-        c.bench_function(&format!("count_zeros 2^{}", log2_size), |b| {
+        c.bench_function(&format!("count_zeros 2^{log2_size}"), |b| {
             b.iter(|| count_zeros(&bytes, 0, bytes.len() * 8))
         });
 
-        c.bench_function(&format!("count_zeros offset 2^{}", log2_size), |b| {
+        c.bench_function(&format!("count_zeros offset 2^{log2_size}"), |b| {
             b.iter(|| count_zeros(&bytes, 10, bytes.len() * 8 - 10))
         });
     })
diff --git a/benches/filter_kernels.rs b/benches/filter_kernels.rs
index 3d61a0cbb0..97e8dc320c 100644
--- a/benches/filter_kernels.rs
+++ b/benches/filter_kernels.rs
@@ -26,7 +26,7 @@ fn bench_filter(data_array: &dyn Array, filter_array: &BooleanArray) {
     criterion::black_box(filter(data_array, filter_array).unwrap());
 }
 
-fn bench_built_filter<'a>(filter: &Filter<'a>, array: &dyn Array) {
+fn bench_built_filter(filter: &Filter, array: &dyn Array) {
     criterion::black_box(filter(array));
 }
 
@@ -40,13 +40,13 @@ fn add_benchmark(c: &mut Criterion) {
             BooleanArray::new(DataType::Boolean, filter_array.values().clone(), None);
 
         let arr_a = create_primitive_array::<f32>(size, 0.0);
-        c.bench_function(&format!("filter 2^{} f32", log2_size), |b| {
+        c.bench_function(&format!("filter 2^{log2_size} f32"), |b| {
             b.iter(|| bench_filter(&arr_a, &filter_array))
         });
 
         let arr_a = create_primitive_array::<f32>(size, 0.1);
 
-        c.bench_function(&format!("filter null 2^{} f32", log2_size), |b| {
+        c.bench_function(&format!("filter null 2^{log2_size} f32"), |b| {
             b.iter(|| bench_filter(&arr_a, &filter_array))
         });
     });
diff --git a/benches/hash_kernel.rs b/benches/hash_kernel.rs
index bf129db6fe..81119b3aaf 100644
--- a/benches/hash_kernel.rs
+++ b/benches/hash_kernel.rs
@@ -9,21 +9,19 @@ fn add_benchmark(c: &mut Criterion) {
 
     let arr_a = create_primitive_array::<i32>(size, 0.0);
 
-    c.bench_function(&format!("i32 2^{}", log2_size), |b| b.iter(|| hash(&arr_a)));
+    c.bench_function(&format!("i32 2^{log2_size}"), |b| b.iter(|| hash(&arr_a)));
 
     let arr_a = create_primitive_array::<i64>(size, 0.0);
 
-    c.bench_function(&format!("i64 2^{}", log2_size), |b| b.iter(|| hash(&arr_a)));
+    c.bench_function(&format!("i64 2^{log2_size}"), |b| b.iter(|| hash(&arr_a)));
 
     let arr_a = create_string_array::<i32>(size, 5, 0.0, 0);
 
-    c.bench_function(&format!("str 2^{}", log2_size), |b| b.iter(|| hash(&arr_a)));
+    c.bench_function(&format!("str 2^{log2_size}"), |b| b.iter(|| hash(&arr_a)));
 
     let arr_a = create_boolean_array(size, 0.5, 0.0);
 
-    c.bench_function(&format!("bool 2^{}", log2_size), |b| {
-        b.iter(|| hash(&arr_a))
-    });
+    c.bench_function(&format!("bool 2^{log2_size}"), |b| b.iter(|| hash(&arr_a)));
 }
 
 criterion_group!(benches, add_benchmark);
diff --git a/benches/iter_list.rs b/benches/iter_list.rs
index 44482567dd..43b7698f3e 100644
--- a/benches/iter_list.rs
+++ b/benches/iter_list.rs
@@ -30,7 +30,7 @@ fn add_benchmark(c: &mut Criterion) {
             Some(validity),
         );
 
-        c.bench_function(&format!("list: iter_values 2^{}", log2_size), |b| {
+        c.bench_function(&format!("list: iter_values 2^{log2_size}"), |b| {
             b.iter(|| {
                 for x in array.values_iter() {
                     assert_eq!(x.len(), 2);
@@ -38,7 +38,7 @@ fn add_benchmark(c: &mut Criterion) {
             })
         });
 
-        c.bench_function(&format!("list: iter 2^{}", log2_size), |b| {
+        c.bench_function(&format!("list: iter 2^{log2_size}"), |b| {
             b.iter(|| {
                 for x in array.iter() {
                     assert_eq!(x.unwrap().len(), 2);
diff --git a/benches/iter_utf8.rs b/benches/iter_utf8.rs
index 44a85d2460..d80ba12389 100644
--- a/benches/iter_utf8.rs
+++ b/benches/iter_utf8.rs
@@ -12,7 +12,7 @@ fn add_benchmark(c: &mut Criterion) {
                 .chain(std::iter::repeat("bbb").take(size / 2)),
         );
 
-        c.bench_function(&format!("iter_values 2^{}", log2_size), |b| {
+        c.bench_function(&format!("iter_values 2^{log2_size}"), |b| {
             b.iter(|| {
                 for x in array.values_iter() {
                     assert_eq!(x.len(), 3);
@@ -20,7 +20,7 @@ fn add_benchmark(c: &mut Criterion) {
             })
         });
 
-        c.bench_function(&format!("iter 2^{}", log2_size), |b| {
+        c.bench_function(&format!("iter 2^{log2_size}"), |b| {
             b.iter(|| {
                 for x in array.iter() {
                     assert_eq!(x.unwrap().len(), 3);
diff --git a/benches/read_json.rs b/benches/read_json.rs
index 5d0400c592..0da79b9437 100644
--- a/benches/read_json.rs
+++ b/benches/read_json.rs
@@ -33,7 +33,7 @@ fn add_benchmark(c: &mut Criterion) {
 
         let (data, dt) = prep(array);
 
-        c.bench_function(&format!("read i32 2^{}", log2_size), |b| {
+        c.bench_function(&format!("read i32 2^{log2_size}"), |b| {
             b.iter(|| bench_read(&data, &dt))
         });
 
@@ -41,7 +41,7 @@ fn add_benchmark(c: &mut Criterion) {
 
         let (data, dt) = prep(array);
 
-        c.bench_function(&format!("read f64 2^{}", log2_size), |b| {
+        c.bench_function(&format!("read f64 2^{log2_size}"), |b| {
             b.iter(|| bench_read(&data, &dt))
         });
 
@@ -49,7 +49,7 @@ fn add_benchmark(c: &mut Criterion) {
 
         let (data, dt) = prep(array);
 
-        c.bench_function(&format!("read utf8 2^{}", log2_size), |b| {
+        c.bench_function(&format!("read utf8 2^{log2_size}"), |b| {
             b.iter(|| bench_read(&data, &dt))
         });
 
@@ -57,7 +57,7 @@ fn add_benchmark(c: &mut Criterion) {
 
         let (data, dt) = prep(array);
 
-        c.bench_function(&format!("read bool 2^{}", log2_size), |b| {
+        c.bench_function(&format!("read bool 2^{log2_size}"), |b| {
             b.iter(|| bench_read(&data, &dt))
         });
     })
diff --git a/benches/read_parquet.rs b/benches/read_parquet.rs
index 0f445fbb01..5aa1696360 100644
--- a/benches/read_parquet.rs
+++ b/benches/read_parquet.rs
@@ -21,8 +21,7 @@ fn to_buffer(
     let nullable = if nullable { "" } else { "_required" };
 
     let path = PathBuf::from(dir).join(format!(
-        "fixtures/pyarrow3/v1/{}{}{}benches{}_{}.parquet",
-        dict, multi_page, compressed, nullable, size
+        "fixtures/pyarrow3/v1/{dict}{multi_page}{compressed}benches{nullable}_{size}.parquet",
     ));
 
     let metadata = fs::metadata(&path).expect("unable to read metadata");
@@ -51,50 +50,50 @@ fn read_chunk(buffer: &[u8], size: usize, column: usize) -> Result<()> {
 }
 
 fn add_benchmark(c: &mut Criterion) {
-    (10..=20).step_by(2).for_each(|i| {
-        let size = 2usize.pow(i);
+    (10..=20).step_by(2).for_each(|log2_size| {
+        let size = 2usize.pow(log2_size);
         let buffer = to_buffer(size, true, false, false, false);
-        let a = format!("read i64 2^{}", i);
+        let a = format!("read i64 2^{log2_size}");
         c.bench_function(&a, |b| b.iter(|| read_chunk(&buffer, size, 0).unwrap()));
 
         let buffer = to_buffer(size, true, true, false, false);
-        let a = format!("read ts dict 2^{}", i);
+        let a = format!("read ts dict 2^{log2_size}");
         c.bench_function(&a, |b| b.iter(|| read_chunk(&buffer, size, 11).unwrap()));
 
-        let a = format!("read utf8 2^{}", i);
+        let a = format!("read utf8 2^{log2_size}");
         c.bench_function(&a, |b| b.iter(|| read_chunk(&buffer, size, 2).unwrap()));
 
-        let a = format!("read utf8 large 2^{}", i);
+        let a = format!("read utf8 large 2^{log2_size}");
         c.bench_function(&a, |b| b.iter(|| read_chunk(&buffer, size, 6).unwrap()));
 
-        let a = format!("read utf8 emoji 2^{}", i);
+        let a = format!("read utf8 emoji 2^{log2_size}");
         c.bench_function(&a, |b| b.iter(|| read_chunk(&buffer, size, 12).unwrap()));
 
-        let a = format!("read bool 2^{}", i);
+        let a = format!("read bool 2^{log2_size}");
         c.bench_function(&a, |b| b.iter(|| read_chunk(&buffer, size, 3).unwrap()));
 
         let buffer = to_buffer(size, true, true, false, false);
-        let a = format!("read utf8 dict 2^{}", i);
+        let a = format!("read utf8 dict 2^{log2_size}");
         c.bench_function(&a, |b| b.iter(|| read_chunk(&buffer, size, 2).unwrap()));
 
         let buffer = to_buffer(size, true, false, false, true);
-        let a = format!("read i64 snappy 2^{}", i);
+        let a = format!("read i64 snappy 2^{log2_size}");
         c.bench_function(&a, |b| b.iter(|| read_chunk(&buffer, size, 0).unwrap()));
 
         let buffer = to_buffer(size, true, false, true, false);
-        let a = format!("read utf8 multi 2^{}", i);
+        let a = format!("read utf8 multi 2^{log2_size}");
         c.bench_function(&a, |b| b.iter(|| read_chunk(&buffer, size, 2).unwrap()));
 
         let buffer = to_buffer(size, true, false, true, true);
-        let a = format!("read utf8 multi snappy 2^{}", i);
+        let a = format!("read utf8 multi snappy 2^{log2_size}");
         c.bench_function(&a, |b| b.iter(|| read_chunk(&buffer, size, 2).unwrap()));
 
         let buffer = to_buffer(size, true, false, true, true);
-        let a = format!("read i64 multi snappy 2^{}", i);
+        let a = format!("read i64 multi snappy 2^{log2_size}");
         c.bench_function(&a, |b| b.iter(|| read_chunk(&buffer, size, 0).unwrap()));
 
         let buffer = to_buffer(size, false, false, false, false);
-        let a = format!("read required utf8 2^{}", i);
+        let a = format!("read required utf8 2^{log2_size}");
         c.bench_function(&a, |b| b.iter(|| read_chunk(&buffer, size, 2).unwrap()));
     });
 }
diff --git a/benches/slices_iterator.rs b/benches/slices_iterator.rs
index 4a4e81e27a..cea662d16a 100644
--- a/benches/slices_iterator.rs
+++ b/benches/slices_iterator.rs
@@ -15,7 +15,7 @@ fn add_benchmark(c: &mut Criterion) {
         let size = 2usize.pow(log2_size);
 
         let bitmap: Bitmap = (0..size).into_iter().map(|x| x % 3 == 0).collect();
-        c.bench_function(&format!("bitmap slices 2^{}", log2_size), |b| {
+        c.bench_function(&format!("bitmap slices 2^{log2_size}"), |b| {
             b.iter(|| bench_slices(&bitmap))
         });
     });
diff --git a/benches/sort_kernel.rs b/benches/sort_kernel.rs
index b0736a2756..562d7d7b44 100644
--- a/benches/sort_kernel.rs
+++ b/benches/sort_kernel.rs
@@ -54,32 +54,32 @@ fn add_benchmark(c: &mut Criterion) {
         let size = 2usize.pow(log2_size);
         let arr_a = create_primitive_array::<f32>(size, 0.0);
 
-        c.bench_function(&format!("sort 2^{} f32", log2_size), |b| {
+        c.bench_function(&format!("sort 2^{log2_size} f32"), |b| {
             b.iter(|| bench_sort(&arr_a))
         });
 
-        c.bench_function(&format!("sort-limit 2^{} f32", log2_size), |b| {
+        c.bench_function(&format!("sort-limit 2^{log2_size} f32"), |b| {
             b.iter(|| bench_sort_limit(&arr_a))
         });
 
         let arr_b = create_primitive_array_with_seed::<f32>(size, 0.0, 43);
-        c.bench_function(&format!("lexsort 2^{} f32", log2_size), |b| {
+        c.bench_function(&format!("lexsort 2^{log2_size} f32"), |b| {
             b.iter(|| bench_lexsort(&arr_a, &arr_b))
         });
 
         let arr_a = create_primitive_array::<f32>(size, 0.5);
 
-        c.bench_function(&format!("sort null 2^{} f32", log2_size), |b| {
+        c.bench_function(&format!("sort null 2^{log2_size} f32"), |b| {
             b.iter(|| bench_sort(&arr_a))
         });
 
         let arr_b = create_primitive_array_with_seed::<f32>(size, 0.5, 43);
-        c.bench_function(&format!("lexsort null 2^{} f32", log2_size), |b| {
+        c.bench_function(&format!("lexsort null 2^{log2_size} f32"), |b| {
             b.iter(|| bench_lexsort(&arr_a, &arr_b))
         });
 
         let arr_a = create_string_array::<i32>(size, 4, 0.1, 42);
-        c.bench_function(&format!("sort utf8 null 2^{}", log2_size), |b| {
+        c.bench_function(&format!("sort utf8 null 2^{log2_size}"), |b| {
             b.iter(|| bench_sort(&arr_a))
         });
     });
diff --git a/benches/take_kernels.rs b/benches/take_kernels.rs
index 0ae1e48296..f18e091d12 100644
--- a/benches/take_kernels.rs
+++ b/benches/take_kernels.rs
@@ -32,43 +32,43 @@ fn add_benchmark(c: &mut Criterion) {
         let values_nulls = create_primitive_array::<i32>(size, 0.2);
         let indices = create_random_index(size, 0.0);
         let indices_nulls = create_random_index(size, 0.5);
-        c.bench_function(&format!("take i32 2^{}", log2_size), |b| {
+        c.bench_function(&format!("take i32 2^{log2_size}"), |b| {
             b.iter(|| bench_take(&values, &indices))
         });
 
-        c.bench_function(&format!("take i32 nulls 2^{}", log2_size), |b| {
+        c.bench_function(&format!("take i32 nulls 2^{log2_size}"), |b| {
             b.iter(|| bench_take(&values, &indices_nulls))
         });
 
-        c.bench_function(&format!("take i32 values nulls 2^{}", log2_size), |b| {
+        c.bench_function(&format!("take i32 values nulls 2^{log2_size}"), |b| {
             b.iter(|| bench_take(&values_nulls, &indices))
         });
 
         let values = create_boolean_array(size, 0.0, 0.5);
-        c.bench_function(&format!("take bool 2^{}", log2_size), |b| {
+        c.bench_function(&format!("take bool 2^{log2_size}"), |b| {
             b.iter(|| bench_take(&values, &indices))
         });
 
         let values_nulls = create_boolean_array(size, 0.2, 0.5);
-        c.bench_function(&format!("take bool values nulls 2^{}", log2_size), |b| {
+        c.bench_function(&format!("take bool values nulls 2^{log2_size}"), |b| {
             b.iter(|| bench_take(&values_nulls, &indices))
         });
 
-        c.bench_function(&format!("take bool nulls 2^{}", log2_size), |b| {
+        c.bench_function(&format!("take bool nulls 2^{log2_size}"), |b| {
             b.iter(|| bench_take(&values, &indices_nulls))
         });
 
         let values = create_string_array::<i32>(512, 4, 0.0, 42);
-        c.bench_function(&format!("take str 2^{}", log2_size), |b| {
+        c.bench_function(&format!("take str 2^{log2_size}"), |b| {
             b.iter(|| bench_take(&values, &indices))
         });
 
-        c.bench_function(&format!("take str nulls 2^{}", log2_size), |b| {
+        c.bench_function(&format!("take str nulls 2^{log2_size}"), |b| {
             b.iter(|| bench_take(&values, &indices_nulls))
         });
 
         let values_nulls = create_string_array::<i32>(size, 4, 0.2, 42);
-        c.bench_function(&format!("take str values nulls 2^{}", log2_size), |b| {
+        c.bench_function(&format!("take str values nulls 2^{log2_size}"), |b| {
             b.iter(|| bench_take(&values_nulls, &indices))
         });
     });
diff --git a/benches/unset_count.rs b/benches/unset_count.rs
index 069fa40315..38d1570d21 100644
--- a/benches/unset_count.rs
+++ b/benches/unset_count.rs
@@ -10,11 +10,11 @@ fn add_benchmark(c: &mut Criterion) {
             .map(|x| 0b01011011u8.rotate_left(x))
             .collect::<Vec<_>>();
 
-        c.bench_function(&format!("count_zeros 2^{}", log2_size), |b| {
+        c.bench_function(&format!("count_zeros 2^{log2_size}"), |b| {
             b.iter(|| count_zeros(&bytes, 0, bytes.len() * 8))
         });
 
-        c.bench_function(&format!("count_zeros offset 2^{}", log2_size), |b| {
+        c.bench_function(&format!("count_zeros offset 2^{log2_size}"), |b| {
             b.iter(|| count_zeros(&bytes, 10, bytes.len() * 8 - 10))
         });
     })
diff --git a/benches/write_csv.rs b/benches/write_csv.rs
index ee30d9ec3a..7778b0781f 100644
--- a/benches/write_csv.rs
+++ b/benches/write_csv.rs
@@ -29,21 +29,21 @@ fn add_benchmark(c: &mut Criterion) {
         let array = create_primitive_array::<i32>(size, 0.1);
         let batch = make_chunk(array);
 
-        c.bench_function(&format!("csv write i32 2^{}", log2_size), |b| {
+        c.bench_function(&format!("csv write i32 2^{log2_size}"), |b| {
             b.iter(|| write_batch(&batch))
         });
 
         let array = create_string_array::<i32>(size, 100, 0.1, 42);
         let batch = make_chunk(array);
 
-        c.bench_function(&format!("csv write utf8 2^{}", log2_size), |b| {
+        c.bench_function(&format!("csv write utf8 2^{log2_size}"), |b| {
             b.iter(|| write_batch(&batch))
         });
 
         let array = create_primitive_array::<f64>(size, 0.1);
         let batch = make_chunk(array);
 
-        c.bench_function(&format!("csv write f64 2^{}", log2_size), |b| {
+        c.bench_function(&format!("csv write f64 2^{log2_size}"), |b| {
             b.iter(|| write_batch(&batch))
         });
     });
diff --git a/benches/write_json.rs b/benches/write_json.rs
index ee8880546f..d4f464040e 100644
--- a/benches/write_json.rs
+++ b/benches/write_json.rs
@@ -25,19 +25,19 @@ fn add_benchmark(c: &mut Criterion) {
 
         let array = create_primitive_array::<i32>(size, 0.1);
 
-        c.bench_function(&format!("json write i32 2^{}", log2_size), |b| {
+        c.bench_function(&format!("json write i32 2^{log2_size}"), |b| {
             b.iter(|| write_array(Box::new(array.clone())))
         });
 
         let array = create_string_array::<i32>(size, 100, 0.1, 42);
 
-        c.bench_function(&format!("json write utf8 2^{}", log2_size), |b| {
+        c.bench_function(&format!("json write utf8 2^{log2_size}"), |b| {
             b.iter(|| write_array(Box::new(array.clone())))
         });
 
         let array = create_primitive_array::<f64>(size, 0.1);
 
-        c.bench_function(&format!("json write f64 2^{}", log2_size), |b| {
+        c.bench_function(&format!("json write f64 2^{log2_size}"), |b| {
             b.iter(|| write_array(Box::new(array.clone())))
         });
     });
diff --git a/examples/avro_read.rs b/examples/avro_read.rs
index 749cf3c50d..6f45afae32 100644
--- a/examples/avro_read.rs
+++ b/examples/avro_read.rs
@@ -17,7 +17,7 @@ fn main() -> Result<()> {
 
     let schema = read::infer_schema(&metadata.record)?;
 
-    println!("{:#?}", metadata);
+    println!("{metadata:#?}");
 
     let reader = read::Reader::new(file, metadata, schema.fields, None);
 
diff --git a/examples/csv_read.rs b/examples/csv_read.rs
index c2661f8a6a..21addf9d0f 100644
--- a/examples/csv_read.rs
+++ b/examples/csv_read.rs
@@ -34,6 +34,6 @@ fn main() -> Result<()> {
     let file_path = &args[1];
 
     let batch = read_path(file_path, None)?;
-    println!("{:?}", batch);
+    println!("{batch:?}");
     Ok(())
 }
diff --git a/examples/csv_read_parallel.rs b/examples/csv_read_parallel.rs
index 9d84d979ff..0c3f6e2b10 100644
--- a/examples/csv_read_parallel.rs
+++ b/examples/csv_read_parallel.rs
@@ -43,7 +43,7 @@ fn parallel_read(path: &str) -> Result<Vec<Chunk<Box<dyn Array>>>> {
         let child = thread::spawn(move || {
             let (rows, line_number) = rx_consumer.recv().unwrap();
             let start = SystemTime::now();
-            println!("consumer start - {}", line_number);
+            println!("consumer start - {line_number}");
             let batch = read::deserialize_batch(
                 &rows,
                 &consumer_fields,
diff --git a/examples/json_read.rs b/examples/json_read.rs
index b674f4a996..edea82f275 100644
--- a/examples/json_read.rs
+++ b/examples/json_read.rs
@@ -26,6 +26,6 @@ fn main() -> Result<()> {
     let file_path = &args[1];
 
     let batch = read_path(file_path)?;
-    println!("{:#?}", batch);
+    println!("{batch:#?}");
     Ok(())
 }
diff --git a/examples/ndjson_read.rs b/examples/ndjson_read.rs
index 93b7b64ba2..bd242d22df 100644
--- a/examples/ndjson_read.rs
+++ b/examples/ndjson_read.rs
@@ -34,6 +34,6 @@ fn main() -> Result<()> {
     let file_path = &args[1];
 
     let arrays = read_path(file_path)?;
-    println!("{:#?}", arrays);
+    println!("{arrays:#?}");
     Ok(())
 }
diff --git a/examples/parquet_read.rs b/examples/parquet_read.rs
index fa0a769d44..eefb2d23d6 100644
--- a/examples/parquet_read.rs
+++ b/examples/parquet_read.rs
@@ -23,7 +23,7 @@ fn main() -> Result<(), Error> {
     // we can read the statistics of all parquet's row groups (here for each field)
     for field in &schema.fields {
         let statistics = read::statistics::deserialize(field, &metadata.row_groups)?;
-        println!("{:#?}", statistics);
+        println!("{statistics:#?}");
     }
 
     // say we found that we only need to read the first two row groups, "0" and "1"
diff --git a/src/array/binary/fmt.rs b/src/array/binary/fmt.rs
index c2ec8737fb..884afe0faf 100644
--- a/src/array/binary/fmt.rs
+++ b/src/array/binary/fmt.rs
@@ -21,7 +21,7 @@ impl<O: Offset> Debug for BinaryArray<O> {
         } else {
             "BinaryArray"
         };
-        write!(f, "{}", head)?;
+        write!(f, "{head}")?;
         write_vec(f, writer, self.validity(), self.len(), "None", false)
     }
 }
diff --git a/src/array/dictionary/fmt.rs b/src/array/dictionary/fmt.rs
index f5f7662400..c98ac5f523 100644
--- a/src/array/dictionary/fmt.rs
+++ b/src/array/dictionary/fmt.rs
@@ -18,7 +18,7 @@ pub fn write_value<K: DictionaryKey, W: Write>(
         let key = array.key_value(index);
         get_display(values.as_ref(), null)(f, key)
     } else {
-        write!(f, "{}", null)
+        write!(f, "{null}")
     }
 }
 
diff --git a/src/array/fixed_size_list/mutable.rs b/src/array/fixed_size_list/mutable.rs
index 0c6c09fe3d..d929f75e6e 100644
--- a/src/array/fixed_size_list/mutable.rs
+++ b/src/array/fixed_size_list/mutable.rs
@@ -52,7 +52,7 @@ impl<M: MutableArray> MutableFixedSizeListArray<M> {
         assert_eq!(values.len(), 0);
         match data_type {
             DataType::FixedSizeList(..) => (),
-            _ => panic!("data type must be FixedSizeList (got {:?})", data_type),
+            _ => panic!("data type must be FixedSizeList (got {data_type:?})"),
         };
         Self {
             size,
diff --git a/src/array/fmt.rs b/src/array/fmt.rs
index 39f4f8b160..36cb2f4e45 100644
--- a/src/array/fmt.rs
+++ b/src/array/fmt.rs
@@ -13,7 +13,7 @@ pub fn get_value_display<'a, F: Write + 'a>(
 ) -> Box<dyn Fn(&mut F, usize) -> Result + 'a> {
     use crate::datatypes::PhysicalType::*;
     match array.data_type().to_physical_type() {
-        Null => Box::new(move |f, _| write!(f, "{}", null)),
+        Null => Box::new(move |f, _| write!(f, "{null}")),
         Boolean => Box::new(|f, index| {
             super::boolean::fmt::write_value(array.as_any().downcast_ref().unwrap(), index, f)
         }),
@@ -152,7 +152,7 @@ where
             if val.get_bit(index) {
                 d(f, index)
             } else {
-                write!(f, "{}", null)
+                write!(f, "{null}")
             }
         } else {
             d(f, index)
diff --git a/src/array/list/fmt.rs b/src/array/list/fmt.rs
index 4b10fc8f93..2f23de0841 100644
--- a/src/array/list/fmt.rs
+++ b/src/array/list/fmt.rs
@@ -25,7 +25,7 @@ impl<O: Offset> Debug for ListArray<O> {
         } else {
             "ListArray"
         };
-        write!(f, "{}", head)?;
+        write!(f, "{head}")?;
         write_vec(f, writer, self.validity(), self.len(), "None", false)
     }
 }
diff --git a/src/array/ord.rs b/src/array/ord.rs
index e42c7fa0fc..439efa1e21 100644
--- a/src/array/ord.rs
+++ b/src/array/ord.rs
@@ -230,16 +230,14 @@ pub fn build_compare(left: &dyn Array, right: &dyn Array) -> Result<DynComparato
                 (IntegerType::Int64, IntegerType::Int64) => dyn_dict!(i64, left, right),
                 (lhs, _) => {
                     return Err(Error::InvalidArgumentError(format!(
-                        "Dictionaries do not support keys of type {:?}",
-                        lhs
+                        "Dictionaries do not support keys of type {lhs:?}"
                     )))
                 }
             }
         }
         (lhs, _) => {
             return Err(Error::InvalidArgumentError(format!(
-                "The data type type {:?} has no natural order",
-                lhs
+                "The data type type {lhs:?} has no natural order"
             )))
         }
     })
diff --git a/src/array/primitive/fmt.rs b/src/array/primitive/fmt.rs
index f21b095862..05357ef587 100644
--- a/src/array/primitive/fmt.rs
+++ b/src/array/primitive/fmt.rs
@@ -94,7 +94,7 @@ pub fn get_write_value<'a, T: NativeType, F: Write>(
             }
         }
         Interval(IntervalUnit::YearMonth) => {
-            dyn_primitive!(array, i32, |x| format!("{}m", x))
+            dyn_primitive!(array, i32, |x| format!("{x}m"))
         }
         Interval(IntervalUnit::DayTime) => {
             dyn_primitive!(array, days_ms, |x: days_ms| format!(
@@ -111,10 +111,10 @@ pub fn get_write_value<'a, T: NativeType, F: Write>(
                 x.ns()
             ))
         }
-        Duration(TimeUnit::Second) => dyn_primitive!(array, i64, |x| format!("{}s", x)),
-        Duration(TimeUnit::Millisecond) => dyn_primitive!(array, i64, |x| format!("{}ms", x)),
-        Duration(TimeUnit::Microsecond) => dyn_primitive!(array, i64, |x| format!("{}us", x)),
-        Duration(TimeUnit::Nanosecond) => dyn_primitive!(array, i64, |x| format!("{}ns", x)),
+        Duration(TimeUnit::Second) => dyn_primitive!(array, i64, |x| format!("{x}s")),
+        Duration(TimeUnit::Millisecond) => dyn_primitive!(array, i64, |x| format!("{x}ms")),
+        Duration(TimeUnit::Microsecond) => dyn_primitive!(array, i64, |x| format!("{x}us")),
+        Duration(TimeUnit::Nanosecond) => dyn_primitive!(array, i64, |x| format!("{x}ns")),
         Decimal(_, scale) => {
             // The number 999.99 has a precision of 5 and scale of 2
             let scale = *scale as u32;
@@ -122,7 +122,7 @@ pub fn get_write_value<'a, T: NativeType, F: Write>(
             let display = move |x: i128| {
                 let base = x / factor;
                 let decimals = (x - base * factor).abs();
-                format!("{}.{}", base, decimals)
+                format!("{base}.{decimals}")
             };
             dyn_primitive!(array, i128, display)
         }
@@ -132,7 +132,7 @@ pub fn get_write_value<'a, T: NativeType, F: Write>(
             let display = move |x: i256| {
                 let base = x.0 / factor;
                 let decimals = (x.0 - base * factor).abs();
-                format!("{}.{}", base, decimals)
+                format!("{base}.{decimals}")
             };
             dyn_primitive!(array, i256, display)
         }
diff --git a/src/array/specification.rs b/src/array/specification.rs
index 274321be93..0645050979 100644
--- a/src/array/specification.rs
+++ b/src/array/specification.rs
@@ -126,7 +126,7 @@ pub(crate) unsafe fn check_indexes_unchecked<K: DictionaryKey>(
 
     if invalid {
         let key = keys.iter().map(|k| k.as_usize()).max().unwrap();
-        Err(Error::oos(format!("One of the dictionary keys is {} but it must be < than the length of the dictionary values, which is {}", key, len)))
+        Err(Error::oos(format!("One of the dictionary keys is {key} but it must be < than the length of the dictionary values, which is {len}")))
     } else {
         Ok(())
     }
@@ -139,9 +139,9 @@ where
     keys.iter().try_for_each(|key| {
         let key: usize = (*key)
             .try_into()
-            .map_err(|_| Error::oos(format!("The dictionary key must fit in a `usize`, but {:?} does not", key)))?;
+            .map_err(|_| Error::oos(format!("The dictionary key must fit in a `usize`, but {key:?} does not")))?;
         if key >= len {
-            Err(Error::oos(format!("One of the dictionary keys is {} but it must be < than the length of the dictionary values, which is {}", key, len)))
+            Err(Error::oos(format!("One of the dictionary keys is {key} but it must be < than the length of the dictionary values, which is {len}")))
         } else {
             Ok(())
         }
diff --git a/src/array/utf8/fmt.rs b/src/array/utf8/fmt.rs
index 1b6868c4a0..97576d3a71 100644
--- a/src/array/utf8/fmt.rs
+++ b/src/array/utf8/fmt.rs
@@ -18,7 +18,7 @@ impl<O: Offset> Debug for Utf8Array<O> {
         } else {
             "Utf8Array"
         };
-        write!(f, "{}", head)?;
+        write!(f, "{head}")?;
         write_vec(f, writer, self.validity(), self.len(), "None", false)
     }
 }
diff --git a/src/bitmap/utils/fmt.rs b/src/bitmap/utils/fmt.rs
index 9575cf18c9..45fe9ec9ce 100644
--- a/src/bitmap/utils/fmt.rs
+++ b/src/bitmap/utils/fmt.rs
@@ -46,7 +46,7 @@ pub fn fmt(
     let number_of_bytes = remaining / 8;
     for byte in &bytes[..number_of_bytes] {
         f.write_str(", ")?;
-        f.write_fmt(format_args!("{:#010b}", byte))?;
+        f.write_fmt(format_args!("{byte:#010b}"))?;
     }
     remaining -= number_of_bytes * 8;
     if remaining == 0 {
diff --git a/src/compute/aggregate/memory.rs b/src/compute/aggregate/memory.rs
index 90a2bc3a76..d497a60ae9 100644
--- a/src/compute/aggregate/memory.rs
+++ b/src/compute/aggregate/memory.rs
@@ -67,7 +67,7 @@ pub fn estimated_bytes_size(array: &dyn Array) -> usize {
                 + validity_size(array.validity())
         }
         FixedSizeList => {
-            let array = array.as_any().downcast_ref::<ListArray<i64>>().unwrap();
+            let array = array.as_any().downcast_ref::<FixedSizeListArray>().unwrap();
             estimated_bytes_size(array.values().as_ref()) + validity_size(array.validity())
         }
         LargeList => {
diff --git a/src/compute/arithmetics/decimal/add.rs b/src/compute/arithmetics/decimal/add.rs
index b8775bd1a2..9f6f529e88 100644
--- a/src/compute/arithmetics/decimal/add.rs
+++ b/src/compute/arithmetics/decimal/add.rs
@@ -44,8 +44,7 @@ pub fn add(lhs: &PrimitiveArray<i128>, rhs: &PrimitiveArray<i128>) -> PrimitiveA
 
         assert!(
             res.abs() <= max,
-            "Overflow in addition presented for precision {}",
-            precision
+            "Overflow in addition presented for precision {precision}"
         );
 
         res
diff --git a/src/compute/arithmetics/decimal/div.rs b/src/compute/arithmetics/decimal/div.rs
index 01f590b992..159c27de2b 100644
--- a/src/compute/arithmetics/decimal/div.rs
+++ b/src/compute/arithmetics/decimal/div.rs
@@ -57,8 +57,7 @@ pub fn div(lhs: &PrimitiveArray<i128>, rhs: &PrimitiveArray<i128>) -> PrimitiveA
 
         assert!(
             res.abs() <= max,
-            "Overflow in multiplication presented for precision {}",
-            precision
+            "Overflow in multiplication presented for precision {precision}"
         );
 
         res
@@ -100,8 +99,7 @@ pub fn div_scalar(lhs: &PrimitiveArray<i128>, rhs: &PrimitiveScalar<i128>) -> Pr
 
         assert!(
             res.abs() <= max,
-            "Overflow in multiplication presented for precision {}",
-            precision
+            "Overflow in multiplication presented for precision {precision}"
         );
 
         res
diff --git a/src/compute/arithmetics/decimal/mul.rs b/src/compute/arithmetics/decimal/mul.rs
index b279673a5d..ac702d2cb3 100644
--- a/src/compute/arithmetics/decimal/mul.rs
+++ b/src/compute/arithmetics/decimal/mul.rs
@@ -58,8 +58,7 @@ pub fn mul(lhs: &PrimitiveArray<i128>, rhs: &PrimitiveArray<i128>) -> PrimitiveA
 
         assert!(
             res.abs() <= max,
-            "Overflow in multiplication presented for precision {}",
-            precision
+            "Overflow in multiplication presented for precision {precision}"
         );
 
         res
@@ -104,8 +103,7 @@ pub fn mul_scalar(lhs: &PrimitiveArray<i128>, rhs: &PrimitiveScalar<i128>) -> Pr
 
         assert!(
             res.abs() <= max,
-            "Overflow in multiplication presented for precision {}",
-            precision
+            "Overflow in multiplication presented for precision {precision}"
         );
 
         res
diff --git a/src/compute/arithmetics/decimal/sub.rs b/src/compute/arithmetics/decimal/sub.rs
index 1f6adca58f..84afd20543 100644
--- a/src/compute/arithmetics/decimal/sub.rs
+++ b/src/compute/arithmetics/decimal/sub.rs
@@ -42,8 +42,7 @@ pub fn sub(lhs: &PrimitiveArray<i128>, rhs: &PrimitiveArray<i128>) -> PrimitiveA
 
         assert!(
             res.abs() <= max,
-            "Overflow in subtract presented for precision {}",
-            precision
+            "Overflow in subtract presented for precision {precision}"
         );
 
         res
diff --git a/src/compute/cast/mod.rs b/src/compute/cast/mod.rs
index d4d4738075..24f5689f38 100644
--- a/src/compute/cast/mod.rs
+++ b/src/compute/cast/mod.rs
@@ -495,8 +495,7 @@ pub fn cast(array: &dyn Array, to_type: &DataType, options: CastOptions) -> Resu
             Float32 => primitive_to_boolean_dyn::<f32>(array, to_type.clone()),
             Float64 => primitive_to_boolean_dyn::<f64>(array, to_type.clone()),
             _ => Err(Error::NotYetImplemented(format!(
-                "Casting from {:?} to {:?} not supported",
-                from_type, to_type,
+                "Casting from {from_type:?} to {to_type:?} not supported",
             ))),
         },
         (Boolean, _) => match to_type {
@@ -515,8 +514,7 @@ pub fn cast(array: &dyn Array, to_type: &DataType, options: CastOptions) -> Resu
             Binary => boolean_to_binary_dyn::<i32>(array),
             LargeBinary => boolean_to_binary_dyn::<i64>(array),
             _ => Err(Error::NotYetImplemented(format!(
-                "Casting from {:?} to {:?} not supported",
-                from_type, to_type,
+                "Casting from {from_type:?} to {to_type:?} not supported",
             ))),
         },
 
@@ -546,8 +544,7 @@ pub fn cast(array: &dyn Array, to_type: &DataType, options: CastOptions) -> Resu
                 utf8_to_timestamp_ns_dyn::<i32>(array, tz.clone())
             }
             _ => Err(Error::NotYetImplemented(format!(
-                "Casting from {:?} to {:?} not supported",
-                from_type, to_type,
+                "Casting from {from_type:?} to {to_type:?} not supported",
             ))),
         },
         (LargeUtf8, _) => match to_type {
@@ -574,8 +571,7 @@ pub fn cast(array: &dyn Array, to_type: &DataType, options: CastOptions) -> Resu
                 utf8_to_timestamp_ns_dyn::<i64>(array, tz.clone())
             }
             _ => Err(Error::NotYetImplemented(format!(
-                "Casting from {:?} to {:?} not supported",
-                from_type, to_type,
+                "Casting from {from_type:?} to {to_type:?} not supported",
             ))),
         },
 
@@ -610,8 +606,7 @@ pub fn cast(array: &dyn Array, to_type: &DataType, options: CastOptions) -> Resu
                 Ok(Box::new(naive_timestamp_to_utf8::<i32>(from, *from_unit)))
             }
             _ => Err(Error::NotYetImplemented(format!(
-                "Casting from {:?} to {:?} not supported",
-                from_type, to_type,
+                "Casting from {from_type:?} to {to_type:?} not supported",
             ))),
         },
 
@@ -641,8 +636,7 @@ pub fn cast(array: &dyn Array, to_type: &DataType, options: CastOptions) -> Resu
                 Ok(Box::new(naive_timestamp_to_utf8::<i64>(from, *from_unit)))
             }
             _ => Err(Error::NotYetImplemented(format!(
-                "Casting from {:?} to {:?} not supported",
-                from_type, to_type,
+                "Casting from {from_type:?} to {to_type:?} not supported",
             ))),
         },
 
@@ -665,8 +659,7 @@ pub fn cast(array: &dyn Array, to_type: &DataType, options: CastOptions) -> Resu
                 .map(|x| x.boxed()),
 
             _ => Err(Error::NotYetImplemented(format!(
-                "Casting from {:?} to {:?} not supported",
-                from_type, to_type,
+                "Casting from {from_type:?} to {to_type:?} not supported",
             ))),
         },
 
@@ -690,8 +683,7 @@ pub fn cast(array: &dyn Array, to_type: &DataType, options: CastOptions) -> Resu
                     .map(|x| x.boxed())
             }
             _ => Err(Error::NotYetImplemented(format!(
-                "Casting from {:?} to {:?} not supported",
-                from_type, to_type,
+                "Casting from {from_type:?} to {to_type:?} not supported",
             ))),
         },
 
@@ -707,8 +699,7 @@ pub fn cast(array: &dyn Array, to_type: &DataType, options: CastOptions) -> Resu
             Float32 => primitive_to_binary_dyn::<f32, i32>(array),
             Float64 => primitive_to_binary_dyn::<f64, i32>(array),
             _ => Err(Error::NotYetImplemented(format!(
-                "Casting from {:?} to {:?} not supported",
-                from_type, to_type,
+                "Casting from {from_type:?} to {to_type:?} not supported",
             ))),
         },
 
@@ -724,8 +715,7 @@ pub fn cast(array: &dyn Array, to_type: &DataType, options: CastOptions) -> Resu
             Float32 => primitive_to_binary_dyn::<f32, i64>(array),
             Float64 => primitive_to_binary_dyn::<f64, i64>(array),
             _ => Err(Error::NotYetImplemented(format!(
-                "Casting from {:?} to {:?} not supported",
-                from_type, to_type,
+                "Casting from {from_type:?} to {to_type:?} not supported",
             ))),
         },
 
@@ -919,8 +909,7 @@ pub fn cast(array: &dyn Array, to_type: &DataType, options: CastOptions) -> Resu
         }
 
         (_, _) => Err(Error::NotYetImplemented(format!(
-            "Casting from {:?} to {:?} not supported",
-            from_type, to_type,
+            "Casting from {from_type:?} to {to_type:?} not supported",
         ))),
     }
 }
@@ -950,8 +939,7 @@ fn cast_to_dictionary<K: DictionaryKey>(
         DataType::Binary => binary_to_dictionary_dyn::<i32, K>(array),
         DataType::LargeBinary => binary_to_dictionary_dyn::<i64, K>(array),
         _ => Err(Error::NotYetImplemented(format!(
-            "Unsupported output type for dictionary packing: {:?}",
-            dict_value_type
+            "Unsupported output type for dictionary packing: {dict_value_type:?}"
         ))),
     }
 }
diff --git a/src/compute/contains.rs b/src/compute/contains.rs
index 738a8e11e5..4fa9ea29ea 100644
--- a/src/compute/contains.rs
+++ b/src/compute/contains.rs
@@ -192,8 +192,7 @@ pub fn contains(list: &dyn Array, values: &dyn Array) -> Result<BooleanArray> {
         (DataType::LargeList(_), DataType::Float32) => primitive!(list, values, i64, f32),
         (DataType::LargeList(_), DataType::Float64) => primitive!(list, values, i64, f64),
         _ => Err(Error::NotYetImplemented(format!(
-            "Contains is not supported between logical types \"{:?}\" and \"{:?}\"",
-            list_data_type, values_data_type
+            "Contains is not supported between logical types \"{list_data_type:?}\" and \"{values_data_type:?}\""
         ))),
     }
 }
diff --git a/src/compute/hash.rs b/src/compute/hash.rs
index d5f8370d8b..319542222e 100644
--- a/src/compute/hash.rs
+++ b/src/compute/hash.rs
@@ -118,8 +118,7 @@ pub fn hash(array: &dyn Array) -> Result<PrimitiveArray<u64>> {
         LargeUtf8 => hash_utf8::<i64>(array.as_any().downcast_ref().unwrap()),
         t => {
             return Err(Error::NotYetImplemented(format!(
-                "Hash not implemented for type {:?}",
-                t
+                "Hash not implemented for type {t:?}"
             )))
         }
     })
diff --git a/src/compute/like.rs b/src/compute/like.rs
index 5c736cd8b5..98c1ea92f2 100644
--- a/src/compute/like.rs
+++ b/src/compute/like.rs
@@ -79,10 +79,9 @@ fn a_like_utf8<O: Offset, F: Fn(bool) -> bool>(
                         pattern
                     } else {
                         let re_pattern = replace_pattern(pattern);
-                        let re = Regex::new(&format!("^{}$", re_pattern)).map_err(|e| {
+                        let re = Regex::new(&format!("^{re_pattern}$")).map_err(|e| {
                             Error::InvalidArgumentError(format!(
-                                "Unable to build regex from LIKE pattern: {}",
-                                e
+                                "Unable to build regex from LIKE pattern: {e}"
                             ))
                         })?;
                         map.insert(pattern, re);
@@ -155,8 +154,8 @@ fn a_like_utf8_scalar<O: Offset, F: Fn(bool) -> bool>(
         Bitmap::from_trusted_len_iter(lhs.values_iter().map(|x| op(x.ends_with(ends_with))))
     } else {
         let re_pattern = replace_pattern(rhs);
-        let re = Regex::new(&format!("^{}$", re_pattern)).map_err(|e| {
-            Error::InvalidArgumentError(format!("Unable to build regex from LIKE pattern: {}", e))
+        let re = Regex::new(&format!("^{re_pattern}$")).map_err(|e| {
+            Error::InvalidArgumentError(format!("Unable to build regex from LIKE pattern: {e}"))
         })?;
         Bitmap::from_trusted_len_iter(lhs.values_iter().map(|x| op(re.is_match(x))))
     };
@@ -227,10 +226,9 @@ fn a_like_binary<O: Offset, F: Fn(bool) -> bool>(
                     } else {
                         let re_pattern = simdutf8::basic::from_utf8(pattern).unwrap();
                         let re_pattern = replace_pattern(re_pattern);
-                        let re = BytesRegex::new(&format!("^{}$", re_pattern)).map_err(|e| {
+                        let re = BytesRegex::new(&format!("^{re_pattern}$")).map_err(|e| {
                             Error::InvalidArgumentError(format!(
-                                "Unable to build regex from LIKE pattern: {}",
-                                e
+                                "Unable to build regex from LIKE pattern: {e}"
                             ))
                         })?;
                         map.insert(pattern, re);
@@ -289,10 +287,7 @@ fn a_like_binary_scalar<O: Offset, F: Fn(bool) -> bool>(
 ) -> Result<BooleanArray> {
     let validity = lhs.validity();
     let pattern = simdutf8::basic::from_utf8(rhs).map_err(|e| {
-        Error::InvalidArgumentError(format!(
-            "Unable to convert the LIKE pattern to string: {}",
-            e
-        ))
+        Error::InvalidArgumentError(format!("Unable to convert the LIKE pattern to string: {e}"))
     })?;
 
     let values = if !pattern.contains(is_like_pattern) {
@@ -310,8 +305,8 @@ fn a_like_binary_scalar<O: Offset, F: Fn(bool) -> bool>(
         Bitmap::from_trusted_len_iter(lhs.values_iter().map(|x| op(x.ends_with(ends_with))))
     } else {
         let re_pattern = replace_pattern(pattern);
-        let re = BytesRegex::new(&format!("^{}$", re_pattern)).map_err(|e| {
-            Error::InvalidArgumentError(format!("Unable to build regex from LIKE pattern: {}", e))
+        let re = BytesRegex::new(&format!("^{re_pattern}$")).map_err(|e| {
+            Error::InvalidArgumentError(format!("Unable to build regex from LIKE pattern: {e}"))
         })?;
         Bitmap::from_trusted_len_iter(lhs.values_iter().map(|x| op(re.is_match(x))))
     };
diff --git a/src/compute/regex_match.rs b/src/compute/regex_match.rs
index 371eb073e4..f0cd2acade 100644
--- a/src/compute/regex_match.rs
+++ b/src/compute/regex_match.rs
@@ -34,10 +34,7 @@ pub fn regex_match<O: Offset>(values: &Utf8Array<O>, regex: &Utf8Array<O>) -> Re
             regex
         } else {
             let re = Regex::new(regex).map_err(|e| {
-                Error::InvalidArgumentError(format!(
-                    "Unable to build regex from LIKE pattern: {}",
-                    e
-                ))
+                Error::InvalidArgumentError(format!("Unable to build regex from LIKE pattern: {e}"))
             })?;
             map.insert(regex, re);
             map.get(regex).unwrap()
@@ -63,7 +60,7 @@ pub fn regex_match<O: Offset>(values: &Utf8Array<O>, regex: &Utf8Array<O>) -> Re
 /// ```
 pub fn regex_match_scalar<O: Offset>(values: &Utf8Array<O>, regex: &str) -> Result<BooleanArray> {
     let regex = Regex::new(regex)
-        .map_err(|e| Error::InvalidArgumentError(format!("Unable to compile regex: {}", e)))?;
+        .map_err(|e| Error::InvalidArgumentError(format!("Unable to compile regex: {e}")))?;
     Ok(unary_utf8_boolean(values, |x| regex.is_match(x)))
 }
 
diff --git a/src/compute/sort/mod.rs b/src/compute/sort/mod.rs
index 5394e37028..92272d057c 100644
--- a/src/compute/sort/mod.rs
+++ b/src/compute/sort/mod.rs
@@ -165,8 +165,7 @@ pub fn sort_to_indices<I: Index>(
                 DataType::UInt32 => Ok(sort_list::<I, i32, u32>(values, v, n, options, limit)),
                 DataType::UInt64 => Ok(sort_list::<I, i32, u64>(values, v, n, options, limit)),
                 t => Err(Error::NotYetImplemented(format!(
-                    "Sort not supported for list type {:?}",
-                    t
+                    "Sort not supported for list type {t:?}"
                 ))),
             }
         }
@@ -182,8 +181,7 @@ pub fn sort_to_indices<I: Index>(
                 DataType::UInt32 => Ok(sort_list::<I, i64, u32>(values, v, n, options, limit)),
                 DataType::UInt64 => Ok(sort_list::<I, i64, u64>(values, v, n, options, limit)),
                 t => Err(Error::NotYetImplemented(format!(
-                    "Sort not supported for list type {:?}",
-                    t
+                    "Sort not supported for list type {t:?}"
                 ))),
             }
         }
@@ -199,8 +197,7 @@ pub fn sort_to_indices<I: Index>(
                 DataType::UInt32 => Ok(sort_list::<I, i32, u32>(values, v, n, options, limit)),
                 DataType::UInt64 => Ok(sort_list::<I, i32, u64>(values, v, n, options, limit)),
                 t => Err(Error::NotYetImplemented(format!(
-                    "Sort not supported for list type {:?}",
-                    t
+                    "Sort not supported for list type {t:?}"
                 ))),
             }
         }
@@ -208,13 +205,11 @@ pub fn sort_to_indices<I: Index>(
             DataType::Utf8 => Ok(sort_dict::<I, i32>(values, key_type, options, limit)),
             DataType::LargeUtf8 => Ok(sort_dict::<I, i64>(values, key_type, options, limit)),
             t => Err(Error::NotYetImplemented(format!(
-                "Sort not supported for dictionary type with keys {:?}",
-                t
+                "Sort not supported for dictionary type with keys {t:?}"
             ))),
         },
         t => Err(Error::NotYetImplemented(format!(
-            "Sort not supported for data type {:?}",
-            t
+            "Sort not supported for data type {t:?}"
         ))),
     }
 }
diff --git a/src/compute/sort/row/dictionary.rs b/src/compute/sort/row/dictionary.rs
index e97a71aba7..fc7b80b30a 100644
--- a/src/compute/sort/row/dictionary.rs
+++ b/src/compute/sort/row/dictionary.rs
@@ -80,8 +80,7 @@ pub fn compute_dictionary_mapping(
         }
         t => {
             return Err(Error::NotYetImplemented(format!(
-                "dictionary value {:?} is not supported",
-                t
+                "dictionary value {t:?} is not supported"
             )))
         }
     })
diff --git a/src/compute/sort/row/mod.rs b/src/compute/sort/row/mod.rs
index e342537d68..2388a6c868 100644
--- a/src/compute/sort/row/mod.rs
+++ b/src/compute/sort/row/mod.rs
@@ -509,8 +509,7 @@ fn new_empty_rows(
             }),
             t => {
                 return Err(Error::NotYetImplemented(format!(
-                    "not yet implemented: {:?}",
-                    t
+                    "not yet implemented: {t:?}"
                 )))
             }
         }
diff --git a/src/compute/take/boolean.rs b/src/compute/take/boolean.rs
index 76ef8c67b3..8a3b7c859b 100644
--- a/src/compute/take/boolean.rs
+++ b/src/compute/take/boolean.rs
@@ -48,7 +48,7 @@ fn take_indices_validity<I: Index>(
                 if !validity.get_bit(i) {
                     false
                 } else {
-                    panic!("Out-of-bounds index {}", index)
+                    panic!("Out-of-bounds index {index}")
                 }
             }
         }
diff --git a/src/compute/take/primitive.rs b/src/compute/take/primitive.rs
index bd033680b6..3708fe0247 100644
--- a/src/compute/take/primitive.rs
+++ b/src/compute/take/primitive.rs
@@ -60,7 +60,7 @@ fn take_indices_validity<T: NativeType, I: Index>(
                     if !validity.get_bit(i) {
                         T::default()
                     } else {
-                        panic!("Out-of-bounds index {}", index)
+                        panic!("Out-of-bounds index {index}")
                     }
                 }
             }
diff --git a/src/error.rs b/src/error.rs
index 52a8cd9062..e5e55b50c6 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -77,18 +77,18 @@ impl Display for Error {
             Error::External(message, source) => {
                 write!(f, "External error{}: {}", message, &source)
             }
-            Error::Io(desc) => write!(f, "Io error: {}", desc),
+            Error::Io(desc) => write!(f, "Io error: {desc}"),
             Error::InvalidArgumentError(desc) => {
-                write!(f, "Invalid argument error: {}", desc)
+                write!(f, "Invalid argument error: {desc}")
             }
             Error::ExternalFormat(desc) => {
-                write!(f, "External format error: {}", desc)
+                write!(f, "External format error: {desc}")
             }
             Error::Overflow => {
                 write!(f, "Operation overflew the backing container.")
             }
             Error::OutOfSpec(message) => {
-                write!(f, "{}", message)
+                write!(f, "{message}")
             }
         }
     }
diff --git a/src/ffi/schema.rs b/src/ffi/schema.rs
index 143a2f477e..2751583ef1 100644
--- a/src/ffi/schema.rs
+++ b/src/ffi/schema.rs
@@ -374,8 +374,7 @@ unsafe fn to_data_type(schema: &ArrowSchema) -> Result<DataType> {
                 }
                 _ => {
                     return Err(Error::OutOfSpec(format!(
-                        "The datatype \"{}\" is still not supported in Rust implementation",
-                        other
+                        "The datatype \"{other}\" is still not supported in Rust implementation",
                     )));
                 }
             }
@@ -437,16 +436,16 @@ fn to_format(data_type: &DataType) -> String {
                 tz.as_ref().map(|x| x.as_ref()).unwrap_or("")
             )
         }
-        DataType::Decimal(precision, scale) => format!("d:{},{}", precision, scale),
-        DataType::Decimal256(precision, scale) => format!("d:{},{},256", precision, scale),
+        DataType::Decimal(precision, scale) => format!("d:{precision},{scale}"),
+        DataType::Decimal256(precision, scale) => format!("d:{precision},{scale},256"),
         DataType::List(_) => "+l".to_string(),
         DataType::LargeList(_) => "+L".to_string(),
         DataType::Struct(_) => "+s".to_string(),
-        DataType::FixedSizeBinary(size) => format!("w:{}", size),
-        DataType::FixedSizeList(_, size) => format!("+w:{}", size),
+        DataType::FixedSizeBinary(size) => format!("w:{size}"),
+        DataType::FixedSizeList(_, size) => format!("+w:{size}"),
         DataType::Union(f, ids, mode) => {
             let sparsness = if mode.is_sparse() { 's' } else { 'd' };
-            let mut r = format!("+u{}:", sparsness);
+            let mut r = format!("+u{sparsness}:");
             let ids = if let Some(ids) = ids {
                 ids.iter()
                     .fold(String::new(), |a, b| a + &b.to_string() + ",")
@@ -473,8 +472,7 @@ pub(super) fn get_child(data_type: &DataType, index: usize) -> Result<DataType>
         (index, DataType::Union(fields, _, _)) => Ok(fields[index].data_type().clone()),
         (index, DataType::Extension(_, subtype, _)) => get_child(subtype, index),
         (child, data_type) => Err(Error::OutOfSpec(format!(
-            "Requested child {} to type {:?} that has no such child",
-            child, data_type
+            "Requested child {child} to type {data_type:?} that has no such child",
         ))),
     }
 }
diff --git a/src/io/avro/read/deserialize.rs b/src/io/avro/read/deserialize.rs
index 6d95fe1914..d2de2a7ac4 100644
--- a/src/io/avro/read/deserialize.rs
+++ b/src/io/avro/read/deserialize.rs
@@ -65,8 +65,7 @@ fn make_mutable(
             }
             other => {
                 return Err(Error::NotYetImplemented(format!(
-                    "Deserializing type {:#?} is still not implemented",
-                    other
+                    "Deserializing type {other:#?} is still not implemented"
                 )))
             }
         },
diff --git a/src/io/avro/read/schema.rs b/src/io/avro/read/schema.rs
index b45fc95c0e..3a920286c0 100644
--- a/src/io/avro/read/schema.rs
+++ b/src/io/avro/read/schema.rs
@@ -95,8 +95,7 @@ fn schema_to_field(schema: &AvroSchema, name: Option<&str>, props: Metadata) ->
                     schema_to_field(schema, None, Metadata::default())?.data_type
                 } else {
                     return Err(Error::NotYetImplemented(format!(
-                        "Can't read avro union {:?}",
-                        schema
+                        "Can't read avro union {schema:?}"
                     )));
                 }
             } else {
diff --git a/src/io/avro/write/mod.rs b/src/io/avro/write/mod.rs
index f821f0dd1e..6448782bb4 100644
--- a/src/io/avro/write/mod.rs
+++ b/src/io/avro/write/mod.rs
@@ -10,7 +10,7 @@ pub use serialize::{can_serialize, new_serializer, BoxSerializer};
 /// # Panics
 /// Panics iff the number of items in any of the serializers is not equal to the number of rows
 /// declared in the `block`.
-pub fn serialize<'a>(serializers: &mut [BoxSerializer<'a>], block: &mut Block) {
+pub fn serialize(serializers: &mut [BoxSerializer], block: &mut Block) {
     let Block {
         data,
         number_of_rows,
diff --git a/src/io/avro/write/schema.rs b/src/io/avro/write/schema.rs
index b0904ca89c..7e049bd431 100644
--- a/src/io/avro/write/schema.rs
+++ b/src/io/avro/write/schema.rs
@@ -45,7 +45,7 @@ fn type_to_schema(
 
 fn _get_field_name(name_counter: &mut i32) -> String {
     *name_counter += 1;
-    format!("r{}", name_counter)
+    format!("r{name_counter}")
 }
 
 fn _type_to_schema(data_type: &DataType, name_counter: &mut i32) -> Result<AvroSchema> {
@@ -86,11 +86,6 @@ fn _type_to_schema(data_type: &DataType, name_counter: &mut i32) -> Result<AvroS
         }
         DataType::FixedSizeBinary(size) => AvroSchema::Fixed(Fixed::new("", *size)),
         DataType::Decimal(p, s) => AvroSchema::Bytes(Some(BytesLogical::Decimal(*p, *s))),
-        other => {
-            return Err(Error::NotYetImplemented(format!(
-                "write {:?} to avro",
-                other
-            )))
-        }
+        other => return Err(Error::NotYetImplemented(format!("write {other:?} to avro"))),
     })
 }
diff --git a/src/io/csv/read_utils.rs b/src/io/csv/read_utils.rs
index 278dd32cb2..2212ac45ac 100644
--- a/src/io/csv/read_utils.rs
+++ b/src/io/csv/read_utils.rs
@@ -235,8 +235,7 @@ pub(crate) fn deserialize_column<B: ByteRecordGeneric>(
         LargeBinary => deserialize_binary::<i64, _>(rows, column),
         other => {
             return Err(Error::NotYetImplemented(format!(
-                "Deserializing type \"{:?}\" is not implemented",
-                other
+                "Deserializing type \"{other:?}\" is not implemented"
             )))
         }
     })
diff --git a/src/io/csv/utils.rs b/src/io/csv/utils.rs
index 436c7d192f..fa8c01f43d 100644
--- a/src/io/csv/utils.rs
+++ b/src/io/csv/utils.rs
@@ -34,7 +34,7 @@ fn is_datetime(string: &str) -> Option<String> {
         parsed.offset.map(|x| {
             let hours = x / 60 / 60;
             let minutes = x / 60 - hours * 60;
-            format!("{:03}:{:02}", hours, minutes)
+            format!("{hours:03}:{minutes:02}")
         })
     } else {
         None
diff --git a/src/io/csv/write/serialize.rs b/src/io/csv/write/serialize.rs
index 46addc378f..7543ef16d9 100644
--- a/src/io/csv/write/serialize.rs
+++ b/src/io/csv/write/serialize.rs
@@ -127,7 +127,7 @@ fn timestamp_with_tz_default<'a>(
             move |x, buf| {
                 if let Some(x) = x {
                     let dt = temporal_conversions::timestamp_to_datetime(*x, time_unit, &timezone);
-                    let _ = write!(StringWrap(buf), "{}", dt);
+                    let _ = write!(StringWrap(buf), "{dt}");
                 }
             },
             vec![],
@@ -141,7 +141,7 @@ fn timestamp_with_tz_default<'a>(
                     if let Some(x) = x {
                         let dt =
                             temporal_conversions::timestamp_to_datetime(*x, time_unit, &timezone);
-                        let _ = write!(StringWrap(buf), "{}", dt);
+                        let _ = write!(StringWrap(buf), "{dt}");
                     }
                 },
                 vec![],
@@ -171,7 +171,7 @@ fn timestamp_with_tz_with_format<'a>(
                 if let Some(x) = x {
                     let dt = temporal_conversions::timestamp_to_datetime(*x, time_unit, &timezone)
                         .format(format);
-                    let _ = write!(StringWrap(buf), "{}", dt);
+                    let _ = write!(StringWrap(buf), "{dt}");
                 }
             },
             vec![],
@@ -186,7 +186,7 @@ fn timestamp_with_tz_with_format<'a>(
                         let dt =
                             temporal_conversions::timestamp_to_datetime(*x, time_unit, &timezone)
                                 .format(format);
-                        let _ = write!(StringWrap(buf), "{}", dt);
+                        let _ = write!(StringWrap(buf), "{dt}");
                     }
                 },
                 vec![],
@@ -462,7 +462,7 @@ pub fn new_serializer<'a>(
                 panic!("only dictionary with string values are supported by csv writer")
             }
         },
-        dt => panic!("data type: {:?} not supported by csv writer", dt),
+        dt => panic!("data type: {dt:?} not supported by csv writer"),
     })
 }
 
diff --git a/src/io/flight/mod.rs b/src/io/flight/mod.rs
index 3c0dc0a919..6291f86e61 100644
--- a/src/io/flight/mod.rs
+++ b/src/io/flight/mod.rs
@@ -124,7 +124,7 @@ pub fn deserialize_batch(
 ) -> Result<Chunk<Box<dyn Array>>> {
     // check that the data_header is a record batch message
     let message = arrow_format::ipc::MessageRef::read_as_root(&data.data_header)
-        .map_err(|err| Error::OutOfSpec(format!("Unable to get root as message: {:?}", err)))?;
+        .map_err(|err| Error::OutOfSpec(format!("Unable to get root as message: {err:?}")))?;
 
     let length = data.data_body.len();
     let mut reader = std::io::Cursor::new(&data.data_body);
@@ -242,8 +242,7 @@ pub fn deserialize_message(
             Ok(None)
         }
         t => Err(Error::nyi(format!(
-            "Reading types other than record batches not yet supported, unable to read {:?}",
-            t
+            "Reading types other than record batches not yet supported, unable to read {t:?}"
         ))),
     }
 }
diff --git a/src/io/ipc/read/array/binary.rs b/src/io/ipc/read/array/binary.rs
index 68c5b40d07..15361da096 100644
--- a/src/io/ipc/read/array/binary.rs
+++ b/src/io/ipc/read/array/binary.rs
@@ -24,8 +24,7 @@ pub fn read_binary<O: Offset, R: Read + Seek>(
 ) -> Result<BinaryArray<O>> {
     let field_node = field_nodes.pop_front().ok_or_else(|| {
         Error::oos(format!(
-            "IPC: unable to fetch the field for {:?}. The file or stream is corrupted.",
-            data_type
+            "IPC: unable to fetch the field for {data_type:?}. The file or stream is corrupted."
         ))
     })?;
 
diff --git a/src/io/ipc/read/array/boolean.rs b/src/io/ipc/read/array/boolean.rs
index f53c0afd99..dbe40b3194 100644
--- a/src/io/ipc/read/array/boolean.rs
+++ b/src/io/ipc/read/array/boolean.rs
@@ -22,8 +22,7 @@ pub fn read_boolean<R: Read + Seek>(
 ) -> Result<BooleanArray> {
     let field_node = field_nodes.pop_front().ok_or_else(|| {
         Error::oos(format!(
-            "IPC: unable to fetch the field for {:?}. The file or stream is corrupted.",
-            data_type
+            "IPC: unable to fetch the field for {data_type:?}. The file or stream is corrupted."
         ))
     })?;
 
diff --git a/src/io/ipc/read/array/dictionary.rs b/src/io/ipc/read/array/dictionary.rs
index f3d92f65a2..e92453528e 100644
--- a/src/io/ipc/read/array/dictionary.rs
+++ b/src/io/ipc/read/array/dictionary.rs
@@ -37,8 +37,7 @@ where
         .ok_or_else(|| {
             let valid_ids = dictionaries.keys().collect::<HashSet<_>>();
             Error::OutOfSpec(format!(
-                "Dictionary id {} not found. Valid ids: {:?}",
-                id, valid_ids
+                "Dictionary id {id} not found. Valid ids: {valid_ids:?}"
             ))
         })?
         .clone();
diff --git a/src/io/ipc/read/array/fixed_size_binary.rs b/src/io/ipc/read/array/fixed_size_binary.rs
index 72e0bd8f5b..79ab0586fa 100644
--- a/src/io/ipc/read/array/fixed_size_binary.rs
+++ b/src/io/ipc/read/array/fixed_size_binary.rs
@@ -22,8 +22,7 @@ pub fn read_fixed_size_binary<R: Read + Seek>(
 ) -> Result<FixedSizeBinaryArray> {
     let field_node = field_nodes.pop_front().ok_or_else(|| {
         Error::oos(format!(
-            "IPC: unable to fetch the field for {:?}. The file or stream is corrupted.",
-            data_type
+            "IPC: unable to fetch the field for {data_type:?}. The file or stream is corrupted."
         ))
     })?;
 
diff --git a/src/io/ipc/read/array/fixed_size_list.rs b/src/io/ipc/read/array/fixed_size_list.rs
index 94c1c7662c..1f5d919c3c 100644
--- a/src/io/ipc/read/array/fixed_size_list.rs
+++ b/src/io/ipc/read/array/fixed_size_list.rs
@@ -27,8 +27,7 @@ pub fn read_fixed_size_list<R: Read + Seek>(
 ) -> Result<FixedSizeListArray> {
     let field_node = field_nodes.pop_front().ok_or_else(|| {
         Error::oos(format!(
-            "IPC: unable to fetch the field for {:?}. The file or stream is corrupted.",
-            data_type
+            "IPC: unable to fetch the field for {data_type:?}. The file or stream is corrupted."
         ))
     })?;
 
diff --git a/src/io/ipc/read/array/list.rs b/src/io/ipc/read/array/list.rs
index 1b45b10730..b6a9ef2615 100644
--- a/src/io/ipc/read/array/list.rs
+++ b/src/io/ipc/read/array/list.rs
@@ -33,8 +33,7 @@ where
 {
     let field_node = field_nodes.pop_front().ok_or_else(|| {
         Error::oos(format!(
-            "IPC: unable to fetch the field for {:?}. The file or stream is corrupted.",
-            data_type
+            "IPC: unable to fetch the field for {data_type:?}. The file or stream is corrupted."
         ))
     })?;
 
diff --git a/src/io/ipc/read/array/map.rs b/src/io/ipc/read/array/map.rs
index 4acec42ef6..b98678e052 100644
--- a/src/io/ipc/read/array/map.rs
+++ b/src/io/ipc/read/array/map.rs
@@ -28,8 +28,7 @@ pub fn read_map<R: Read + Seek>(
 ) -> Result<MapArray> {
     let field_node = field_nodes.pop_front().ok_or_else(|| {
         Error::oos(format!(
-            "IPC: unable to fetch the field for {:?}. The file or stream is corrupted.",
-            data_type
+            "IPC: unable to fetch the field for {data_type:?}. The file or stream is corrupted."
         ))
     })?;
 
diff --git a/src/io/ipc/read/array/null.rs b/src/io/ipc/read/array/null.rs
index 5cf5184c05..eee14608d8 100644
--- a/src/io/ipc/read/array/null.rs
+++ b/src/io/ipc/read/array/null.rs
@@ -11,8 +11,7 @@ use super::super::{Node, OutOfSpecKind};
 pub fn read_null(field_nodes: &mut VecDeque<Node>, data_type: DataType) -> Result<NullArray> {
     let field_node = field_nodes.pop_front().ok_or_else(|| {
         Error::oos(format!(
-            "IPC: unable to fetch the field for {:?}. The file or stream is corrupted.",
-            data_type
+            "IPC: unable to fetch the field for {data_type:?}. The file or stream is corrupted."
         ))
     })?;
 
diff --git a/src/io/ipc/read/array/primitive.rs b/src/io/ipc/read/array/primitive.rs
index bba155f78e..0815d2ae7a 100644
--- a/src/io/ipc/read/array/primitive.rs
+++ b/src/io/ipc/read/array/primitive.rs
@@ -25,8 +25,7 @@ where
 {
     let field_node = field_nodes.pop_front().ok_or_else(|| {
         Error::oos(format!(
-            "IPC: unable to fetch the field for {:?}. The file or stream is corrupted.",
-            data_type
+            "IPC: unable to fetch the field for {data_type:?}. The file or stream is corrupted."
         ))
     })?;
 
diff --git a/src/io/ipc/read/array/struct_.rs b/src/io/ipc/read/array/struct_.rs
index 77f5d74bed..06d0f55ad3 100644
--- a/src/io/ipc/read/array/struct_.rs
+++ b/src/io/ipc/read/array/struct_.rs
@@ -27,8 +27,7 @@ pub fn read_struct<R: Read + Seek>(
 ) -> Result<StructArray> {
     let field_node = field_nodes.pop_front().ok_or_else(|| {
         Error::oos(format!(
-            "IPC: unable to fetch the field for {:?}. The file or stream is corrupted.",
-            data_type
+            "IPC: unable to fetch the field for {data_type:?}. The file or stream is corrupted."
         ))
     })?;
 
diff --git a/src/io/ipc/read/array/union.rs b/src/io/ipc/read/array/union.rs
index 627d912b44..569014797a 100644
--- a/src/io/ipc/read/array/union.rs
+++ b/src/io/ipc/read/array/union.rs
@@ -28,8 +28,7 @@ pub fn read_union<R: Read + Seek>(
 ) -> Result<UnionArray> {
     let field_node = field_nodes.pop_front().ok_or_else(|| {
         Error::oos(format!(
-            "IPC: unable to fetch the field for {:?}. The file or stream is corrupted.",
-            data_type
+            "IPC: unable to fetch the field for {data_type:?}. The file or stream is corrupted."
         ))
     })?;
 
diff --git a/src/io/ipc/read/array/utf8.rs b/src/io/ipc/read/array/utf8.rs
index 398184e3e5..741b2b9158 100644
--- a/src/io/ipc/read/array/utf8.rs
+++ b/src/io/ipc/read/array/utf8.rs
@@ -24,8 +24,7 @@ pub fn read_utf8<O: Offset, R: Read + Seek>(
 ) -> Result<Utf8Array<O>> {
     let field_node = field_nodes.pop_front().ok_or_else(|| {
         Error::oos(format!(
-            "IPC: unable to fetch the field for {:?}. The file or stream is corrupted.",
-            data_type
+            "IPC: unable to fetch the field for {data_type:?}. The file or stream is corrupted."
         ))
     })?;
 
diff --git a/src/io/ipc/read/error.rs b/src/io/ipc/read/error.rs
index 0fdd6a01c9..747f1a5672 100644
--- a/src/io/ipc/read/error.rs
+++ b/src/io/ipc/read/error.rs
@@ -99,7 +99,7 @@ pub enum OutOfSpecKind {
 
 impl From<OutOfSpecKind> for Error {
     fn from(kind: OutOfSpecKind) -> Self {
-        Error::OutOfSpec(format!("{:?}", kind))
+        Error::OutOfSpec(format!("{kind:?}"))
     }
 }
 
diff --git a/src/io/ipc/read/file.rs b/src/io/ipc/read/file.rs
index ad8dc34811..341cdfeba6 100644
--- a/src/io/ipc/read/file.rs
+++ b/src/io/ipc/read/file.rs
@@ -213,7 +213,7 @@ pub(super) fn deserialize_footer(footer_data: &[u8], size: u64) -> Result<FileMe
 pub fn read_file_metadata<R: Read + Seek>(reader: &mut R) -> Result<FileMetadata> {
     // check if header contain the correct magic bytes
     let mut magic_buffer: [u8; 6] = [0; 6];
-    let start = reader.seek(SeekFrom::Current(0))?;
+    let start = reader.stream_position()?;
     reader.read_exact(&mut magic_buffer)?;
     if magic_buffer != ARROW_MAGIC {
         return Err(Error::from(OutOfSpecKind::InvalidHeader));
diff --git a/src/io/ipc/read/schema.rs b/src/io/ipc/read/schema.rs
index 5a9646ea37..7ec87eaa33 100644
--- a/src/io/ipc/read/schema.rs
+++ b/src/io/ipc/read/schema.rs
@@ -96,8 +96,7 @@ fn deserialize_time(time: TimeRef) -> Result<(DataType, IpcField)> {
         (64, TimeUnit::Nanosecond) => DataType::Time64(TimeUnit::Nanosecond),
         (bits, precision) => {
             return Err(Error::nyi(format!(
-                "Time type with bit width of {} and unit of {:?}",
-                bits, precision
+                "Time type with bit width of {bits} and unit of {precision:?}"
             )))
         }
     };
@@ -360,7 +359,7 @@ fn get_data_type(
 /// Deserialize an flatbuffers-encoded Schema message into [`Schema`] and [`IpcSchema`].
 pub fn deserialize_schema(message: &[u8]) -> Result<(Schema, IpcSchema)> {
     let message = arrow_format::ipc::MessageRef::read_as_root(message)
-        .map_err(|err| Error::oos(format!("Unable deserialize message: {:?}", err)))?;
+        .map_err(|err| Error::oos(format!("Unable deserialize message: {err:?}")))?;
 
     let schema = match message
         .header()?
@@ -413,7 +412,7 @@ pub(super) fn fb_to_schema(schema: arrow_format::ipc::SchemaRef) -> Result<(Sche
 
 pub(super) fn deserialize_stream_metadata(meta: &[u8]) -> Result<StreamMetadata> {
     let message = arrow_format::ipc::MessageRef::read_as_root(meta)
-        .map_err(|err| Error::OutOfSpec(format!("Unable to get root as message: {:?}", err)))?;
+        .map_err(|err| Error::OutOfSpec(format!("Unable to get root as message: {err:?}")))?;
     let version = message.version()?;
     // message header is a Schema, so read it
     let header = message
diff --git a/src/io/json/read/deserialize.rs b/src/io/json/read/deserialize.rs
index 73eac81d4f..cad89b2286 100644
--- a/src/io/json/read/deserialize.rs
+++ b/src/io/json/read/deserialize.rs
@@ -657,7 +657,7 @@ pub fn deserialize_records(json: &Value, schema: &Schema) -> Result<Chunk<Box<dy
                     Value::Object(record) => {
                         for (key, value) in record.iter() {
                             let arr = results.get_mut(key).ok_or_else(|| {
-                                Error::ExternalFormat(format!("unexpected key: '{}'", key))
+                                Error::ExternalFormat(format!("unexpected key: '{key}'"))
                             })?;
                             deserialize_into(arr, &[value]);
                         }
diff --git a/src/io/json/read/infer_schema.rs b/src/io/json/read/infer_schema.rs
index 1bab0251ac..f098bf80d3 100644
--- a/src/io/json/read/infer_schema.rs
+++ b/src/io/json/read/infer_schema.rs
@@ -39,7 +39,7 @@ pub fn infer_records_schema(json: &Value) -> Result<Schema> {
                 Ok(Field {
                     name: name.clone(),
                     data_type: DataType::List(Box::new(Field {
-                        name: format!("{}-records", name),
+                        name: format!("{name}-records"),
                         data_type,
                         is_nullable: true,
                         metadata: Metadata::default(),
diff --git a/src/io/json/write/serialize.rs b/src/io/json/write/serialize.rs
index ec1b0d5ee4..2f5da0e63e 100644
--- a/src/io/json/write/serialize.rs
+++ b/src/io/json/write/serialize.rs
@@ -204,7 +204,7 @@ where
         move |x, buf| {
             if let Some(x) = x {
                 let nd = convert(*x);
-                write!(buf, "\"{}\"", nd).unwrap();
+                write!(buf, "\"{nd}\"").unwrap();
             } else {
                 buf.extend_from_slice(b"null")
             }
@@ -225,7 +225,7 @@ where
         move |x, buf| {
             if let Some(x) = x {
                 let ndt = convert(*x);
-                write!(buf, "\"{}\"", ndt).unwrap();
+                write!(buf, "\"{ndt}\"").unwrap();
             } else {
                 buf.extend_from_slice(b"null")
             }
diff --git a/src/io/json_integration/read/array.rs b/src/io/json_integration/read/array.rs
index bca82eafde..c658a2a0cf 100644
--- a/src/io/json_integration/read/array.rs
+++ b/src/io/json_integration/read/array.rs
@@ -261,7 +261,7 @@ fn to_dictionary<K: DictionaryKey + NumCast>(
     let dict_id = field.dictionary_id.unwrap();
     let dictionary = dictionaries
         .get(&dict_id)
-        .ok_or_else(|| Error::OutOfSpec(format!("Unable to find any dictionary id {}", dict_id)))?;
+        .ok_or_else(|| Error::OutOfSpec(format!("Unable to find any dictionary id {dict_id}")))?;
 
     let keys = to_primitive(json_col, K::PRIMITIVE.into());
 
diff --git a/src/io/json_integration/read/schema.rs b/src/io/json_integration/read/schema.rs
index 06e2ecbaf4..6a54dafc2b 100644
--- a/src/io/json_integration/read/schema.rs
+++ b/src/io/json_integration/read/schema.rs
@@ -24,7 +24,7 @@ fn to_time_unit(item: Option<&Value>) -> Result<TimeUnit> {
 fn to_int(item: &Value) -> Result<IntegerType> {
     Ok(match item.get("isSigned") {
         Some(&Value::Bool(true)) => match item.get("bitWidth") {
-            Some(&Value::Number(ref n)) => match n.as_u64() {
+            Some(Value::Number(n)) => match n.as_u64() {
                 Some(8) => IntegerType::Int8,
                 Some(16) => IntegerType::Int16,
                 Some(32) => IntegerType::Int32,
@@ -42,7 +42,7 @@ fn to_int(item: &Value) -> Result<IntegerType> {
             }
         },
         Some(&Value::Bool(false)) => match item.get("bitWidth") {
-            Some(&Value::Number(ref n)) => match n.as_u64() {
+            Some(Value::Number(n)) => match n.as_u64() {
                 Some(8) => IntegerType::UInt8,
                 Some(16) => IntegerType::UInt16,
                 Some(32) => IntegerType::UInt32,
@@ -126,8 +126,7 @@ fn read_metadata(metadata: &Value) -> Result<Metadata> {
                     res.insert(k.clone(), str_value.to_string().clone());
                 } else {
                     return Err(Error::OutOfSpec(format!(
-                        "Field 'metadata' contains non-string value for key {}",
-                        k
+                        "Field 'metadata' contains non-string value for key {k}"
                     )));
                 }
             }
@@ -282,8 +281,7 @@ fn to_data_type(item: &Value, mut children: Vec<Field>) -> Result<DataType> {
         }
         other => {
             return Err(Error::NotYetImplemented(format!(
-                "invalid json value type \"{}\"",
-                other
+                "invalid json value type \"{other}\""
             )))
         }
     })
@@ -338,7 +336,7 @@ fn deserialize_field(value: &Value) -> Result<Field> {
     };
 
     let name = match map.get("name") {
-        Some(&Value::String(ref name)) => name.to_string(),
+        Some(Value::String(name)) => name.to_string(),
         _ => {
             return Err(Error::OutOfSpec(
                 "Field missing 'name' attribute".to_string(),
diff --git a/src/io/ndjson/read/file.rs b/src/io/ndjson/read/file.rs
index 6ed5497489..98ee328115 100644
--- a/src/io/ndjson/read/file.rs
+++ b/src/io/ndjson/read/file.rs
@@ -22,7 +22,7 @@ fn read_rows<R: BufRead>(reader: &mut R, rows: &mut [String], limit: usize) -> R
             row.clear();
             let _ = reader
                 .read_line(row)
-                .map_err(|e| Error::External(format!(" at line {}", row_number), Box::new(e)))?;
+                .map_err(|e| Error::External(format!(" at line {row_number}"), Box::new(e)))?;
             if row.is_empty() {
                 break;
             }
diff --git a/src/io/orc/mod.rs b/src/io/orc/mod.rs
index 6d1ac5953e..9b982a3ca7 100644
--- a/src/io/orc/mod.rs
+++ b/src/io/orc/mod.rs
@@ -7,6 +7,6 @@ use crate::error::Error;
 
 impl From<format::error::Error> for Error {
     fn from(error: format::error::Error) -> Self {
-        Error::ExternalFormat(format!("{:?}", error))
+        Error::ExternalFormat(format!("{error:?}"))
     }
 }
diff --git a/src/io/parquet/read/deserialize/dictionary/mod.rs b/src/io/parquet/read/deserialize/dictionary/mod.rs
index 43fcaa8ab2..7ed3cb6f6f 100644
--- a/src/io/parquet/read/deserialize/dictionary/mod.rs
+++ b/src/io/parquet/read/deserialize/dictionary/mod.rs
@@ -239,8 +239,8 @@ fn finish_key<K: DictionaryKey>(values: Vec<K>, validity: MutableBitmap) -> Prim
 }
 
 #[inline]
-pub(super) fn next_dict<'a, K: DictionaryKey, I: Pages, F: Fn(&DictPage) -> Box<dyn Array>>(
-    iter: &'a mut I,
+pub(super) fn next_dict<K: DictionaryKey, I: Pages, F: Fn(&DictPage) -> Box<dyn Array>>(
+    iter: &mut I,
     items: &mut VecDeque<(Vec<K>, MutableBitmap)>,
     dict: &mut Option<Box<dyn Array>>,
     data_type: DataType,
diff --git a/src/io/parquet/read/deserialize/dictionary/nested.rs b/src/io/parquet/read/deserialize/dictionary/nested.rs
index 89b8701231..a1dec1a28d 100644
--- a/src/io/parquet/read/deserialize/dictionary/nested.rs
+++ b/src/io/parquet/read/deserialize/dictionary/nested.rs
@@ -145,8 +145,8 @@ impl<'a, K: DictionaryKey> NestedDecoder<'a> for DictionaryDecoder<K> {
 }
 
 #[allow(clippy::too_many_arguments)]
-pub fn next_dict<'a, K: DictionaryKey, I: Pages, F: Fn(&DictPage) -> Box<dyn Array>>(
-    iter: &'a mut I,
+pub fn next_dict<K: DictionaryKey, I: Pages, F: Fn(&DictPage) -> Box<dyn Array>>(
+    iter: &mut I,
     items: &mut VecDeque<(NestedState, (Vec<K>, MutableBitmap))>,
     remaining: &mut usize,
     init: &[InitNested],
diff --git a/src/io/parquet/read/deserialize/nested.rs b/src/io/parquet/read/deserialize/nested.rs
index 065190fbb7..4efa7adbcc 100644
--- a/src/io/parquet/read/deserialize/nested.rs
+++ b/src/io/parquet/read/deserialize/nested.rs
@@ -428,8 +428,7 @@ fn dict_read<'a, K: DictionaryKey, I: 'a + Pages>(
          */
         other => {
             return Err(Error::nyi(format!(
-                "Reading nested dictionaries of type {:?}",
-                other
+                "Reading nested dictionaries of type {other:?}"
             )))
         }
     })
diff --git a/src/io/parquet/read/deserialize/simple.rs b/src/io/parquet/read/deserialize/simple.rs
index 8b8ad6db45..cacb518bb3 100644
--- a/src/io/parquet/read/deserialize/simple.rs
+++ b/src/io/parquet/read/deserialize/simple.rs
@@ -103,8 +103,7 @@ pub fn page_iter_to_arrays<'a, I: Pages + 'a>(
             ))),
             other => {
                 return Err(Error::NotYetImplemented(format!(
-                    "Reading uin32 from {:?}-encoded parquet still not implemented",
-                    other
+                    "Reading uin32 from {other:?}-encoded parquet still not implemented"
                 )))
             }
         },
@@ -216,8 +215,7 @@ pub fn page_iter_to_arrays<'a, I: Pages + 'a>(
             ))),
             PhysicalType::FixedLenByteArray(n) if *n > 16 => {
                 return Err(Error::NotYetImplemented(format!(
-                    "Can't decode Decimal128 type from Fixed Size Byte Array of len {:?}",
-                    n
+                    "Can't decode Decimal128 type from Fixed Size Byte Array of len {n:?}"
                 )))
             }
             PhysicalType::FixedLenByteArray(n) => {
@@ -301,8 +299,7 @@ pub fn page_iter_to_arrays<'a, I: Pages + 'a>(
 
         other => {
             return Err(Error::NotYetImplemented(format!(
-                "Reading {:?} from parquet still not implemented",
-                other
+                "Reading {other:?} from parquet still not implemented"
             )))
         }
     })
@@ -545,8 +542,7 @@ fn dict_read<'a, K: DictionaryKey, I: Pages + 'a>(
         )),
         other => {
             return Err(Error::nyi(format!(
-                "Reading dictionaries of type {:?}",
-                other
+                "Reading dictionaries of type {other:?}"
             )))
         }
     })
diff --git a/src/io/parquet/read/deserialize/utils.rs b/src/io/parquet/read/deserialize/utils.rs
index 71bce24c58..9c4855813f 100644
--- a/src/io/parquet/read/deserialize/utils.rs
+++ b/src/io/parquet/read/deserialize/utils.rs
@@ -289,9 +289,9 @@ impl<'a> PageValidity<'a> for OptionalPageValidity<'a> {
 }
 
 /// Extends a [`Pushable`] from an iterator of non-null values and an hybrid-rle decoder
-pub(super) fn extend_from_decoder<'a, T: Default, P: Pushable<T>, I: Iterator<Item = T>>(
+pub(super) fn extend_from_decoder<T: Default, P: Pushable<T>, I: Iterator<Item = T>>(
     validity: &mut MutableBitmap,
-    page_validity: &mut dyn PageValidity<'a>,
+    page_validity: &mut dyn PageValidity,
     limit: Option<usize>,
     pushable: &mut P,
     mut values_iter: I,
diff --git a/src/io/parquet/read/schema/convert.rs b/src/io/parquet/read/schema/convert.rs
index 5f23dc71dd..821d510764 100644
--- a/src/io/parquet/read/schema/convert.rs
+++ b/src/io/parquet/read/schema/convert.rs
@@ -299,7 +299,7 @@ fn to_list(fields: &[ParquetType], parent_name: &str) -> Option<DataType> {
         ParquetType::GroupType { fields, .. } => {
             if fields.len() == 1
                 && item.name() != "array"
-                && item.name() != format!("{}_tuple", parent_name)
+                && item.name() != format!("{parent_name}_tuple")
             {
                 // extract the repetition field
                 let nested_item = fields.first().unwrap();
diff --git a/src/io/parquet/read/schema/metadata.rs b/src/io/parquet/read/schema/metadata.rs
index 469d39bd26..2595083f44 100644
--- a/src/io/parquet/read/schema/metadata.rs
+++ b/src/io/parquet/read/schema/metadata.rs
@@ -31,8 +31,7 @@ fn get_arrow_schema_from_metadata(encoded_meta: &str) -> Result<Schema> {
         Err(err) => {
             // The C++ implementation returns an error if the schema can't be parsed.
             Err(Error::InvalidArgumentError(format!(
-                "Unable to decode the encoded schema stored in {}, {:?}",
-                ARROW_SCHEMA_META_KEY, err
+                "Unable to decode the encoded schema stored in {ARROW_SCHEMA_META_KEY}, {err:?}"
             )))
         }
     }
diff --git a/src/io/parquet/read/statistics/mod.rs b/src/io/parquet/read/statistics/mod.rs
index 599fa0102f..e1ad050564 100644
--- a/src/io/parquet/read/statistics/mod.rs
+++ b/src/io/parquet/read/statistics/mod.rs
@@ -194,8 +194,7 @@ fn make_mutable(data_type: &DataType, capacity: usize) -> Result<Box<dyn Mutable
         )?),
         other => {
             return Err(Error::NotYetImplemented(format!(
-                "Deserializing parquet stats from {:?} is still not implemented",
-                other
+                "Deserializing parquet stats from {other:?} is still not implemented"
             )))
         }
     })
@@ -451,8 +450,7 @@ fn push(
             ParquetPhysicalType::Int64 => primitive::push(from, min, max, |x: i64| Ok(x as u32)),
             ParquetPhysicalType::Int32 => primitive::push(from, min, max, |x: i32| Ok(x as u32)),
             other => Err(Error::NotYetImplemented(format!(
-                "Can't decode UInt32 type from parquet type {:?}",
-                other
+                "Can't decode UInt32 type from parquet type {other:?}"
             ))),
         },
         Int32 => primitive::push::<i32, i32, _>(from, min, max, Ok),
@@ -503,12 +501,9 @@ fn push(
         Decimal(_, _) => match physical_type {
             ParquetPhysicalType::Int32 => primitive::push(from, min, max, |x: i32| Ok(x as i128)),
             ParquetPhysicalType::Int64 => primitive::push(from, min, max, |x: i64| Ok(x as i128)),
-            ParquetPhysicalType::FixedLenByteArray(n) if *n > 16 => {
-                Err(Error::NotYetImplemented(format!(
-                    "Can't decode Decimal128 type from Fixed Size Byte Array of len {:?}",
-                    n
-                )))
-            }
+            ParquetPhysicalType::FixedLenByteArray(n) if *n > 16 => Err(Error::NotYetImplemented(
+                format!("Can't decode Decimal128 type from Fixed Size Byte Array of len {n:?}"),
+            )),
             ParquetPhysicalType::FixedLenByteArray(n) => fixlen::push_i128(from, *n, min, max),
             _ => unreachable!(),
         },
diff --git a/src/io/parquet/write/dictionary.rs b/src/io/parquet/write/dictionary.rs
index 01a5f8412f..38f4e2113c 100644
--- a/src/io/parquet/write/dictionary.rs
+++ b/src/io/parquet/write/dictionary.rs
@@ -229,8 +229,7 @@ pub fn array_to_pages<K: DictionaryKey>(
                 }
                 other => {
                     return Err(Error::NotYetImplemented(format!(
-                        "Writing dictionary arrays to parquet only support data type {:?}",
-                        other
+                        "Writing dictionary arrays to parquet only support data type {other:?}"
                     )))
                 }
             };
diff --git a/src/io/parquet/write/mod.rs b/src/io/parquet/write/mod.rs
index 150211f7c2..5bb0bd0f61 100644
--- a/src/io/parquet/write/mod.rs
+++ b/src/io/parquet/write/mod.rs
@@ -312,8 +312,7 @@ pub fn array_to_page_simple(
     let data_type = array.data_type();
     if !can_encode(data_type, encoding) {
         return Err(Error::InvalidArgumentError(format!(
-            "The datatype {:?} cannot be encoded by {:?}",
-            data_type, encoding
+            "The datatype {data_type:?} cannot be encoded by {encoding:?}"
         )));
     }
 
@@ -527,8 +526,7 @@ pub fn array_to_page_simple(
             }
         }
         other => Err(Error::NotYetImplemented(format!(
-            "Writing parquet pages for data type {:?}",
-            other
+            "Writing parquet pages for data type {other:?}"
         ))),
     }
     .map(Page::Data)
@@ -608,8 +606,7 @@ fn array_to_page_nested(
             primitive::nested_array_to_page::<f64, f64>(array, options, type_, nested)
         }
         other => Err(Error::NotYetImplemented(format!(
-            "Writing nested parquet pages for data type {:?}",
-            other
+            "Writing nested parquet pages for data type {other:?}"
         ))),
     }
     .map(Page::Data)
diff --git a/src/io/parquet/write/schema.rs b/src/io/parquet/write/schema.rs
index bf3100bdcf..248397d241 100644
--- a/src/io/parquet/write/schema.rs
+++ b/src/io/parquet/write/schema.rs
@@ -320,8 +320,7 @@ pub fn to_parquet_type(field: &Field) -> Result<ParquetType> {
             ))
         }
         other => Err(Error::NotYetImplemented(format!(
-            "Writing the data type {:?} is not yet implemented",
-            other
+            "Writing the data type {other:?} is not yet implemented"
         ))),
     }
 }
diff --git a/src/temporal_conversions.rs b/src/temporal_conversions.rs
index 8eae7213fc..fcf2c0a746 100644
--- a/src/temporal_conversions.rs
+++ b/src/temporal_conversions.rs
@@ -273,7 +273,7 @@ fn utf8_to_timestamp_ns_impl<O: Offset, T: chrono::TimeZone>(
 #[cfg_attr(docsrs, doc(cfg(feature = "chrono-tz")))]
 pub fn parse_offset_tz(timezone: &str) -> Result<chrono_tz::Tz> {
     timezone.parse::<chrono_tz::Tz>().map_err(|_| {
-        Error::InvalidArgumentError(format!("timezone \"{}\" cannot be parsed", timezone))
+        Error::InvalidArgumentError(format!("timezone \"{timezone}\" cannot be parsed"))
     })
 }
 


Test patch:
diff --git a/tests/it/array/binary/mod.rs b/tests/it/array/binary/mod.rs
index 2dc185bde9..a36a2a9d25 100644
--- a/tests/it/array/binary/mod.rs
+++ b/tests/it/array/binary/mod.rs
@@ -153,7 +153,7 @@ fn value_unchecked_with_wrong_offsets_panics() {
 fn debug() {
     let array = BinaryArray::<i32>::from([Some([1, 2].as_ref()), Some(&[]), None]);
 
-    assert_eq!(format!("{:?}", array), "BinaryArray[[1, 2], [], None]");
+    assert_eq!(format!("{array:?}"), "BinaryArray[[1, 2], [], None]");
 }
 
 #[test]
diff --git a/tests/it/array/boolean/mod.rs b/tests/it/array/boolean/mod.rs
index c9fa33906f..73d143d1d2 100644
--- a/tests/it/array/boolean/mod.rs
+++ b/tests/it/array/boolean/mod.rs
@@ -59,7 +59,7 @@ fn with_validity() {
 #[test]
 fn debug() {
     let array = BooleanArray::from([Some(true), None, Some(false)]);
-    assert_eq!(format!("{:?}", array), "BooleanArray[true, None, false]");
+    assert_eq!(format!("{array:?}"), "BooleanArray[true, None, false]");
 }
 
 #[test]
diff --git a/tests/it/array/dictionary/mod.rs b/tests/it/array/dictionary/mod.rs
index 3498041700..0ee0c37476 100644
--- a/tests/it/array/dictionary/mod.rs
+++ b/tests/it/array/dictionary/mod.rs
@@ -21,7 +21,7 @@ fn try_new_ok() {
     );
     assert!(!array.is_ordered());
 
-    assert_eq!(format!("{:?}", array), "DictionaryArray[aa, a]");
+    assert_eq!(format!("{array:?}"), "DictionaryArray[aa, a]");
 }
 
 #[test]
@@ -109,7 +109,7 @@ fn new_null() {
     let dt = DataType::Dictionary(i16::KEY_TYPE, Box::new(DataType::Int32), false);
     let array = DictionaryArray::<i16>::new_null(dt, 2);
 
-    assert_eq!(format!("{:?}", array), "DictionaryArray[None, None]");
+    assert_eq!(format!("{array:?}"), "DictionaryArray[None, None]");
 }
 
 #[test]
@@ -117,7 +117,7 @@ fn new_empty() {
     let dt = DataType::Dictionary(i16::KEY_TYPE, Box::new(DataType::Int32), false);
     let array = DictionaryArray::<i16>::new_empty(dt);
 
-    assert_eq!(format!("{:?}", array), "DictionaryArray[]");
+    assert_eq!(format!("{array:?}"), "DictionaryArray[]");
 }
 
 #[test]
@@ -129,7 +129,7 @@ fn with_validity() {
 
     let array = array.with_validity(Some([true, false].into()));
 
-    assert_eq!(format!("{:?}", array), "DictionaryArray[aa, None]");
+    assert_eq!(format!("{array:?}"), "DictionaryArray[aa, None]");
 }
 
 #[test]
diff --git a/tests/it/array/equal/mod.rs b/tests/it/array/equal/mod.rs
index a5d1884cf2..f479b47884 100644
--- a/tests/it/array/equal/mod.rs
+++ b/tests/it/array/equal/mod.rs
@@ -8,11 +8,11 @@ mod utf8;
 
 pub fn test_equal(lhs: &dyn Array, rhs: &dyn Array, expected: bool) {
     // equality is symmetric
-    assert!(equal(lhs, lhs), "\n{:?}\n{:?}", lhs, lhs);
-    assert!(equal(rhs, rhs), "\n{:?}\n{:?}", rhs, rhs);
+    assert!(equal(lhs, lhs), "\n{lhs:?}\n{lhs:?}");
+    assert!(equal(rhs, rhs), "\n{rhs:?}\n{rhs:?}");
 
-    assert_eq!(equal(lhs, rhs), expected, "\n{:?}\n{:?}", lhs, rhs);
-    assert_eq!(equal(rhs, lhs), expected, "\n{:?}\n{:?}", rhs, lhs);
+    assert_eq!(equal(lhs, rhs), expected, "\n{lhs:?}\n{rhs:?}");
+    assert_eq!(equal(rhs, lhs), expected, "\n{rhs:?}\n{lhs:?}");
 }
 
 #[allow(clippy::type_complexity)]
diff --git a/tests/it/array/fixed_size_binary/mod.rs b/tests/it/array/fixed_size_binary/mod.rs
index 920b5925b2..aa1ae6de7e 100644
--- a/tests/it/array/fixed_size_binary/mod.rs
+++ b/tests/it/array/fixed_size_binary/mod.rs
@@ -39,10 +39,7 @@ fn debug() {
         vec![1, 2, 3, 4, 5, 6].into(),
         Some(Bitmap::from([true, false, true])),
     );
-    assert_eq!(
-        format!("{:?}", a),
-        "FixedSizeBinary(2)[[1, 2], None, [5, 6]]"
-    );
+    assert_eq!(format!("{a:?}"), "FixedSizeBinary(2)[[1, 2], None, [5, 6]]");
 }
 
 #[test]
diff --git a/tests/it/array/fixed_size_list/mod.rs b/tests/it/array/fixed_size_list/mod.rs
index 8281aee519..23d37a2a21 100644
--- a/tests/it/array/fixed_size_list/mod.rs
+++ b/tests/it/array/fixed_size_list/mod.rs
@@ -47,7 +47,7 @@ fn with_validity() {
 fn debug() {
     let array = data();
 
-    assert_eq!(format!("{:?}", array), "FixedSizeListArray[[10, 20], None]");
+    assert_eq!(format!("{array:?}"), "FixedSizeListArray[[10, 20], None]");
 }
 
 #[test]
diff --git a/tests/it/array/list/mod.rs b/tests/it/array/list/mod.rs
index bc3caef921..4cbf4dbbec 100644
--- a/tests/it/array/list/mod.rs
+++ b/tests/it/array/list/mod.rs
@@ -17,7 +17,7 @@ fn debug() {
         None,
     );
 
-    assert_eq!(format!("{:?}", array), "ListArray[[1, 2], [], [3], [4, 5]]");
+    assert_eq!(format!("{array:?}"), "ListArray[[1, 2], [], [3], [4, 5]]");
 }
 
 #[test]
@@ -66,5 +66,5 @@ fn test_nested_display() {
     );
 
     let expected = "ListArray[[[1, 2], [3, 4]], [[5, 6, 7], [], [8]], [[9, 10]]]";
-    assert_eq!(format!("{:?}", nested), expected);
+    assert_eq!(format!("{nested:?}"), expected);
 }
diff --git a/tests/it/array/primitive/fmt.rs b/tests/it/array/primitive/fmt.rs
index 4f62e0bf22..c04c1e1c5e 100644
--- a/tests/it/array/primitive/fmt.rs
+++ b/tests/it/array/primitive/fmt.rs
@@ -7,23 +7,20 @@ use arrow2::{
 #[test]
 fn debug_int32() {
     let array = Int32Array::from(&[Some(1), None, Some(2)]);
-    assert_eq!(format!("{:?}", array), "Int32[1, None, 2]");
+    assert_eq!(format!("{array:?}"), "Int32[1, None, 2]");
 }
 
 #[test]
 fn debug_date32() {
     let array = Int32Array::from(&[Some(1), None, Some(2)]).to(DataType::Date32);
-    assert_eq!(
-        format!("{:?}", array),
-        "Date32[1970-01-02, None, 1970-01-03]"
-    );
+    assert_eq!(format!("{array:?}"), "Date32[1970-01-02, None, 1970-01-03]");
 }
 
 #[test]
 fn debug_time32s() {
     let array = Int32Array::from(&[Some(1), None, Some(2)]).to(DataType::Time32(TimeUnit::Second));
     assert_eq!(
-        format!("{:?}", array),
+        format!("{array:?}"),
         "Time32(Second)[00:00:01, None, 00:00:02]"
     );
 }
@@ -33,7 +30,7 @@ fn debug_time32ms() {
     let array =
         Int32Array::from(&[Some(1), None, Some(2)]).to(DataType::Time32(TimeUnit::Millisecond));
     assert_eq!(
-        format!("{:?}", array),
+        format!("{array:?}"),
         "Time32(Millisecond)[00:00:00.001, None, 00:00:00.002]"
     );
 }
@@ -42,22 +39,19 @@ fn debug_time32ms() {
 fn debug_interval_d() {
     let array =
         Int32Array::from(&[Some(1), None, Some(2)]).to(DataType::Interval(IntervalUnit::YearMonth));
-    assert_eq!(format!("{:?}", array), "Interval(YearMonth)[1m, None, 2m]");
+    assert_eq!(format!("{array:?}"), "Interval(YearMonth)[1m, None, 2m]");
 }
 
 #[test]
 fn debug_int64() {
     let array = Int64Array::from(&[Some(1), None, Some(2)]).to(DataType::Int64);
-    assert_eq!(format!("{:?}", array), "Int64[1, None, 2]");
+    assert_eq!(format!("{array:?}"), "Int64[1, None, 2]");
 }
 
 #[test]
 fn debug_date64() {
     let array = Int64Array::from(&[Some(1), None, Some(86400000)]).to(DataType::Date64);
-    assert_eq!(
-        format!("{:?}", array),
-        "Date64[1970-01-01, None, 1970-01-02]"
-    );
+    assert_eq!(format!("{array:?}"), "Date64[1970-01-01, None, 1970-01-02]");
 }
 
 #[test]
@@ -65,7 +59,7 @@ fn debug_time64us() {
     let array =
         Int64Array::from(&[Some(1), None, Some(2)]).to(DataType::Time64(TimeUnit::Microsecond));
     assert_eq!(
-        format!("{:?}", array),
+        format!("{array:?}"),
         "Time64(Microsecond)[00:00:00.000001, None, 00:00:00.000002]"
     );
 }
@@ -75,7 +69,7 @@ fn debug_time64ns() {
     let array =
         Int64Array::from(&[Some(1), None, Some(2)]).to(DataType::Time64(TimeUnit::Nanosecond));
     assert_eq!(
-        format!("{:?}", array),
+        format!("{array:?}"),
         "Time64(Nanosecond)[00:00:00.000000001, None, 00:00:00.000000002]"
     );
 }
@@ -85,7 +79,7 @@ fn debug_timestamp_s() {
     let array =
         Int64Array::from(&[Some(1), None, Some(2)]).to(DataType::Timestamp(TimeUnit::Second, None));
     assert_eq!(
-        format!("{:?}", array),
+        format!("{array:?}"),
         "Timestamp(Second, None)[1970-01-01 00:00:01, None, 1970-01-01 00:00:02]"
     );
 }
@@ -95,7 +89,7 @@ fn debug_timestamp_ms() {
     let array = Int64Array::from(&[Some(1), None, Some(2)])
         .to(DataType::Timestamp(TimeUnit::Millisecond, None));
     assert_eq!(
-        format!("{:?}", array),
+        format!("{array:?}"),
         "Timestamp(Millisecond, None)[1970-01-01 00:00:00.001, None, 1970-01-01 00:00:00.002]"
     );
 }
@@ -105,7 +99,7 @@ fn debug_timestamp_us() {
     let array = Int64Array::from(&[Some(1), None, Some(2)])
         .to(DataType::Timestamp(TimeUnit::Microsecond, None));
     assert_eq!(
-        format!("{:?}", array),
+        format!("{array:?}"),
         "Timestamp(Microsecond, None)[1970-01-01 00:00:00.000001, None, 1970-01-01 00:00:00.000002]"
     );
 }
@@ -115,7 +109,7 @@ fn debug_timestamp_ns() {
     let array = Int64Array::from(&[Some(1), None, Some(2)])
         .to(DataType::Timestamp(TimeUnit::Nanosecond, None));
     assert_eq!(
-        format!("{:?}", array),
+        format!("{array:?}"),
         "Timestamp(Nanosecond, None)[1970-01-01 00:00:00.000000001, None, 1970-01-01 00:00:00.000000002]"
     );
 }
@@ -127,7 +121,7 @@ fn debug_timestamp_tz_ns() {
         Some("+02:00".to_string()),
     ));
     assert_eq!(
-        format!("{:?}", array),
+        format!("{array:?}"),
         "Timestamp(Nanosecond, Some(\"+02:00\"))[1970-01-01 02:00:00.000000001 +02:00, None, 1970-01-01 02:00:00.000000002 +02:00]"
     );
 }
@@ -139,7 +133,7 @@ fn debug_timestamp_tz_not_parsable() {
         Some("aa".to_string()),
     ));
     assert_eq!(
-        format!("{:?}", array),
+        format!("{array:?}"),
         "Timestamp(Nanosecond, Some(\"aa\"))[1 (aa), None, 2 (aa)]"
     );
 }
@@ -152,7 +146,7 @@ fn debug_timestamp_tz1_ns() {
         Some("Europe/Lisbon".to_string()),
     ));
     assert_eq!(
-        format!("{:?}", array),
+        format!("{array:?}"),
         "Timestamp(Nanosecond, Some(\"Europe/Lisbon\"))[1970-01-01 01:00:00.000000001 CET, None, 1970-01-01 01:00:00.000000002 CET]"
     );
 }
@@ -162,7 +156,7 @@ fn debug_duration_ms() {
     let array =
         Int64Array::from(&[Some(1), None, Some(2)]).to(DataType::Duration(TimeUnit::Millisecond));
     assert_eq!(
-        format!("{:?}", array),
+        format!("{array:?}"),
         "Duration(Millisecond)[1ms, None, 2ms]"
     );
 }
@@ -171,7 +165,7 @@ fn debug_duration_ms() {
 fn debug_duration_s() {
     let array =
         Int64Array::from(&[Some(1), None, Some(2)]).to(DataType::Duration(TimeUnit::Second));
-    assert_eq!(format!("{:?}", array), "Duration(Second)[1s, None, 2s]");
+    assert_eq!(format!("{array:?}"), "Duration(Second)[1s, None, 2s]");
 }
 
 #[test]
@@ -179,7 +173,7 @@ fn debug_duration_us() {
     let array =
         Int64Array::from(&[Some(1), None, Some(2)]).to(DataType::Duration(TimeUnit::Microsecond));
     assert_eq!(
-        format!("{:?}", array),
+        format!("{array:?}"),
         "Duration(Microsecond)[1us, None, 2us]"
     );
 }
@@ -188,35 +182,26 @@ fn debug_duration_us() {
 fn debug_duration_ns() {
     let array =
         Int64Array::from(&[Some(1), None, Some(2)]).to(DataType::Duration(TimeUnit::Nanosecond));
-    assert_eq!(
-        format!("{:?}", array),
-        "Duration(Nanosecond)[1ns, None, 2ns]"
-    );
+    assert_eq!(format!("{array:?}"), "Duration(Nanosecond)[1ns, None, 2ns]");
 }
 
 #[test]
 fn debug_decimal() {
     let array = Int128Array::from(&[Some(12345), None, Some(23456)]).to(DataType::Decimal(5, 2));
-    assert_eq!(
-        format!("{:?}", array),
-        "Decimal(5, 2)[123.45, None, 234.56]"
-    );
+    assert_eq!(format!("{array:?}"), "Decimal(5, 2)[123.45, None, 234.56]");
 }
 
 #[test]
 fn debug_decimal1() {
     let array = Int128Array::from(&[Some(12345), None, Some(23456)]).to(DataType::Decimal(5, 1));
-    assert_eq!(
-        format!("{:?}", array),
-        "Decimal(5, 1)[1234.5, None, 2345.6]"
-    );
+    assert_eq!(format!("{array:?}"), "Decimal(5, 1)[1234.5, None, 2345.6]");
 }
 
 #[test]
 fn debug_interval_days_ms() {
     let array = DaysMsArray::from(&[Some(days_ms::new(1, 1)), None, Some(days_ms::new(2, 2))]);
     assert_eq!(
-        format!("{:?}", array),
+        format!("{array:?}"),
         "Interval(DayTime)[1d1ms, None, 2d2ms]"
     );
 }
@@ -232,7 +217,7 @@ fn debug_months_days_ns() {
     let array = MonthsDaysNsArray::from(&data);
 
     assert_eq!(
-        format!("{:?}", array),
+        format!("{array:?}"),
         "Interval(MonthDayNano)[1m1d2ns, None, 2m3d3ns]"
     );
 }
diff --git a/tests/it/array/struct_/mod.rs b/tests/it/array/struct_/mod.rs
index 3eb2f6b5cb..cd32eee3f7 100644
--- a/tests/it/array/struct_/mod.rs
+++ b/tests/it/array/struct_/mod.rs
@@ -21,7 +21,7 @@ fn debug() {
         Some(Bitmap::from([true, true, false, true])),
     );
     assert_eq!(
-        format!("{:?}", array),
+        format!("{array:?}"),
         "StructArray[{b: false, c: 42}, {b: false, c: 28}, None, {b: true, c: 31}]"
     );
 }
diff --git a/tests/it/array/union.rs b/tests/it/array/union.rs
index c250c3ccee..48a1d98f97 100644
--- a/tests/it/array/union.rs
+++ b/tests/it/array/union.rs
@@ -34,7 +34,7 @@ fn sparse_debug() -> Result<()> {
 
     let array = UnionArray::new(data_type, types, fields, None);
 
-    assert_eq!(format!("{:?}", array), "UnionArray[1, None, c]");
+    assert_eq!(format!("{array:?}"), "UnionArray[1, None, c]");
 
     Ok(())
 }
@@ -55,7 +55,7 @@ fn dense_debug() -> Result<()> {
 
     let array = UnionArray::new(data_type, types, fields, offsets);
 
-    assert_eq!(format!("{:?}", array), "UnionArray[1, None, c]");
+    assert_eq!(format!("{array:?}"), "UnionArray[1, None, c]");
 
     Ok(())
 }
diff --git a/tests/it/array/utf8/mod.rs b/tests/it/array/utf8/mod.rs
index d16479c174..e73c688053 100644
--- a/tests/it/array/utf8/mod.rs
+++ b/tests/it/array/utf8/mod.rs
@@ -156,7 +156,7 @@ fn index_out_of_bounds_panics() {
 fn debug() {
     let array = Utf8Array::<i32>::from([Some("aa"), Some(""), None]);
 
-    assert_eq!(format!("{:?}", array), "Utf8Array[aa, , None]");
+    assert_eq!(format!("{array:?}"), "Utf8Array[aa, , None]");
 }
 
 #[test]
diff --git a/tests/it/bitmap/immutable.rs b/tests/it/bitmap/immutable.rs
index 96f0584c99..aa6c8133ac 100644
--- a/tests/it/bitmap/immutable.rs
+++ b/tests/it/bitmap/immutable.rs
@@ -37,5 +37,5 @@ fn debug() {
     let b = Bitmap::from([true, true, false, true, true, true, true, true, true]);
     let b = b.slice(2, 7);
 
-    assert_eq!(format!("{:?}", b), "[0b111110__, 0b_______1]");
+    assert_eq!(format!("{b:?}"), "[0b111110__, 0b_______1]");
 }
diff --git a/tests/it/bitmap/mutable.rs b/tests/it/bitmap/mutable.rs
index 60af81bf92..960c6303e6 100644
--- a/tests/it/bitmap/mutable.rs
+++ b/tests/it/bitmap/mutable.rs
@@ -274,19 +274,19 @@ fn extend_from_bitmap_offset() {
 #[test]
 fn debug() {
     let mut b = MutableBitmap::new();
-    assert_eq!(format!("{:?}", b), "[]");
+    assert_eq!(format!("{b:?}"), "[]");
     b.push(true);
     b.push(false);
-    assert_eq!(format!("{:?}", b), "[0b______01]");
+    assert_eq!(format!("{b:?}"), "[0b______01]");
     b.push(false);
     b.push(false);
     b.push(false);
     b.push(false);
     b.push(true);
     b.push(true);
-    assert_eq!(format!("{:?}", b), "[0b11000001]");
+    assert_eq!(format!("{b:?}"), "[0b11000001]");
     b.push(true);
-    assert_eq!(format!("{:?}", b), "[0b11000001, 0b_______1]");
+    assert_eq!(format!("{b:?}"), "[0b11000001, 0b_______1]");
 }
 
 #[test]
diff --git a/tests/it/buffer/immutable.rs b/tests/it/buffer/immutable.rs
index 9398759e95..7e5661fdd5 100644
--- a/tests/it/buffer/immutable.rs
+++ b/tests/it/buffer/immutable.rs
@@ -33,7 +33,7 @@ fn from_iter() {
 fn debug() {
     let buffer = Buffer::<i32>::from(vec![0, 1, 2, 3]);
     let buffer = buffer.slice(1, 2);
-    let a = format!("{:?}", buffer);
+    let a = format!("{buffer:?}");
     assert_eq!(a, "[1, 2]")
 }
 
diff --git a/tests/it/compute/aggregate/memory.rs b/tests/it/compute/aggregate/memory.rs
index b1a839319a..be6ca35ee0 100644
--- a/tests/it/compute/aggregate/memory.rs
+++ b/tests/it/compute/aggregate/memory.rs
@@ -1,4 +1,8 @@
-use arrow2::{array::*, compute::aggregate::estimated_bytes_size};
+use arrow2::{
+    array::*,
+    compute::aggregate::estimated_bytes_size,
+    datatypes::{DataType, Field},
+};
 
 #[test]
 fn primitive() {
@@ -17,3 +21,12 @@ fn utf8() {
     let a = Utf8Array::<i32>::from_slice(["aaa"]);
     assert_eq!(3 + 2 * std::mem::size_of::<i32>(), estimated_bytes_size(&a));
 }
+
+#[test]
+fn fixed_size_list() {
+    let data_type =
+        DataType::FixedSizeList(Box::new(Field::new("elem", DataType::Float32, false)), 3);
+    let values = Box::new(Float32Array::from_slice([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]));
+    let a = FixedSizeListArray::new(data_type, values, None);
+    assert_eq!(6 * std::mem::size_of::<f32>(), estimated_bytes_size(&a));
+}
diff --git a/tests/it/compute/cast.rs b/tests/it/compute/cast.rs
index 7973ad798f..72bed91f99 100644
--- a/tests/it/compute/cast.rs
+++ b/tests/it/compute/cast.rs
@@ -479,15 +479,12 @@ fn consistency() {
             if can_cast_types(d1, d2) {
                 let result = cast(array.as_ref(), d2, CastOptions::default());
                 if let Ok(result) = result {
-                    assert_eq!(result.data_type(), d2, "type not equal: {:?} {:?}", d1, d2);
+                    assert_eq!(result.data_type(), d2, "type not equal: {d1:?} {d2:?}");
                 } else {
-                    panic!(
-                        "Cast should have not have failed {:?} {:?}: {:?}",
-                        d1, d2, result
-                    );
+                    panic!("Cast should have not have failed {d1:?} {d2:?}: {result:?}");
                 }
             } else if cast(array.as_ref(), d2, CastOptions::default()).is_ok() {
-                panic!("Cast should have failed {:?} {:?}", d1, d2);
+                panic!("Cast should have failed {d1:?} {d2:?}");
             }
         }
     }
diff --git a/tests/it/io/csv/write.rs b/tests/it/io/csv/write.rs
index 87a83170e0..2800c3bd77 100644
--- a/tests/it/io/csv/write.rs
+++ b/tests/it/io/csv/write.rs
@@ -415,12 +415,12 @@ fn write_escaping_resize_local_buf() {
         let a = Utf8Array::<i32>::from_slice([payload]);
         let chunk = Chunk::new(vec![a.boxed()]);
 
-        test_generic(chunk,  &format!("\"{}\"\n", payload));
+        test_generic(chunk,  &format!("\"{payload}\"\n"));
 
         let a = Utf8Array::<i64>::from_slice([payload]);
         let chunk = Chunk::new(vec![a.boxed()]);
 
-        test_generic(chunk,  &format!("\"{}\"\n", payload));
+        test_generic(chunk,  &format!("\"{payload}\"\n"));
     }
 }
 
diff --git a/tests/it/io/ipc/common.rs b/tests/it/io/ipc/common.rs
index 6254c8f5bb..a0889670f3 100644
--- a/tests/it/io/ipc/common.rs
+++ b/tests/it/io/ipc/common.rs
@@ -15,8 +15,7 @@ type IpcRead = (Schema, Vec<IpcField>, Vec<Chunk<Box<dyn Array>>>);
 pub fn read_gzip_json(version: &str, file_name: &str) -> Result<IpcRead> {
     let testdata = crate::test_util::arrow_test_data();
     let file = File::open(format!(
-        "{}/arrow-ipc-stream/integration/{}/{}.json.gz",
-        testdata, version, file_name
+        "{testdata}/arrow-ipc-stream/integration/{version}/{file_name}.json.gz"
     ))
     .unwrap();
     let mut gz = GzDecoder::new(&file);
@@ -54,8 +53,7 @@ pub fn read_arrow_stream(
 ) -> IpcRead {
     let testdata = crate::test_util::arrow_test_data();
     let mut file = File::open(format!(
-        "{}/arrow-ipc-stream/integration/{}/{}.stream",
-        testdata, version, file_name
+        "{testdata}/arrow-ipc-stream/integration/{version}/{file_name}.stream"
     ))
     .unwrap();
 
diff --git a/tests/it/io/ipc/read/file.rs b/tests/it/io/ipc/read/file.rs
index 515a6ede92..663bae0dcc 100644
--- a/tests/it/io/ipc/read/file.rs
+++ b/tests/it/io/ipc/read/file.rs
@@ -9,8 +9,7 @@ use super::super::common::read_gzip_json;
 fn test_file(version: &str, file_name: &str) -> Result<()> {
     let testdata = crate::test_util::arrow_test_data();
     let mut file = File::open(format!(
-        "{}/arrow-ipc-stream/integration/{}/{}.arrow_file",
-        testdata, version, file_name
+        "{testdata}/arrow-ipc-stream/integration/{version}/{file_name}.arrow_file"
     ))?;
 
     // read expected JSON output
@@ -167,8 +166,7 @@ fn read_generated_200_compression_zstd() -> Result<()> {
 fn test_projection(version: &str, file_name: &str, columns: Vec<usize>) -> Result<()> {
     let testdata = crate::test_util::arrow_test_data();
     let mut file = File::open(format!(
-        "{}/arrow-ipc-stream/integration/{}/{}.arrow_file",
-        testdata, version, file_name
+        "{testdata}/arrow-ipc-stream/integration/{version}/{file_name}.arrow_file"
     ))?;
 
     let (schema, _, chunks) = read_gzip_json(version, file_name)?;
@@ -232,10 +230,7 @@ fn test_does_not_panic() {
     let version = "1.0.0-littleendian";
     let file_name = "generated_primitive";
     let testdata = crate::test_util::arrow_test_data();
-    let path = format!(
-        "{}/arrow-ipc-stream/integration/{}/{}.arrow_file",
-        testdata, version, file_name
-    );
+    let path = format!("{testdata}/arrow-ipc-stream/integration/{version}/{file_name}.arrow_file");
     let original = std::fs::read(path).unwrap();
 
     for _ in 0..1000 {
@@ -250,8 +245,7 @@ fn test_does_not_panic() {
 fn test_limit(version: &str, file_name: &str, limit: usize) -> Result<()> {
     let testdata = crate::test_util::arrow_test_data();
     let mut file = File::open(format!(
-        "{}/arrow-ipc-stream/integration/{}/{}.arrow_file",
-        testdata, version, file_name
+        "{testdata}/arrow-ipc-stream/integration/{version}/{file_name}.arrow_file"
     ))?;
 
     let (schema, _, _) = read_gzip_json(version, file_name)?;
diff --git a/tests/it/io/ipc/read/stream.rs b/tests/it/io/ipc/read/stream.rs
index ab8ae45a0e..404954c3e4 100644
--- a/tests/it/io/ipc/read/stream.rs
+++ b/tests/it/io/ipc/read/stream.rs
@@ -9,8 +9,7 @@ use crate::io::ipc::common::read_gzip_json;
 fn test_file(version: &str, file_name: &str) -> Result<()> {
     let testdata = crate::test_util::arrow_test_data();
     let mut file = File::open(format!(
-        "{}/arrow-ipc-stream/integration/{}/{}.stream",
-        testdata, version, file_name
+        "{testdata}/arrow-ipc-stream/integration/{version}/{file_name}.stream"
     ))?;
 
     let metadata = read_stream_metadata(&mut file)?;
@@ -105,8 +104,7 @@ fn read_generated_200_compression_zstd() -> Result<()> {
 fn test_projection(version: &str, file_name: &str, columns: Vec<usize>) -> Result<()> {
     let testdata = crate::test_util::arrow_test_data();
     let mut file = File::open(format!(
-        "{}/arrow-ipc-stream/integration/{}/{}.stream",
-        testdata, version, file_name
+        "{testdata}/arrow-ipc-stream/integration/{version}/{file_name}.stream"
     ))?;
 
     let metadata = read_stream_metadata(&mut file)?;
diff --git a/tests/it/io/ipc/read_file_async.rs b/tests/it/io/ipc/read_file_async.rs
index b8b61853a3..8b74e6592c 100644
--- a/tests/it/io/ipc/read_file_async.rs
+++ b/tests/it/io/ipc/read_file_async.rs
@@ -10,8 +10,7 @@ use crate::io::ipc::common::read_gzip_json;
 async fn test_file(version: &str, file_name: &str) -> Result<()> {
     let testdata = crate::test_util::arrow_test_data();
     let mut file = File::open(format!(
-        "{}/arrow-ipc-stream/integration/{}/{}.arrow_file",
-        testdata, version, file_name
+        "{testdata}/arrow-ipc-stream/integration/{version}/{file_name}.arrow_file"
     ))
     .await?
     .compat();
diff --git a/tests/it/io/ipc/read_stream_async.rs b/tests/it/io/ipc/read_stream_async.rs
index 593e2b0aeb..bb248932e9 100644
--- a/tests/it/io/ipc/read_stream_async.rs
+++ b/tests/it/io/ipc/read_stream_async.rs
@@ -10,8 +10,7 @@ use crate::io::ipc::common::read_gzip_json;
 async fn test_file(version: &str, file_name: &str) -> Result<()> {
     let testdata = crate::test_util::arrow_test_data();
     let mut file = File::open(format!(
-        "{}/arrow-ipc-stream/integration/{}/{}.stream",
-        testdata, version, file_name
+        "{testdata}/arrow-ipc-stream/integration/{version}/{file_name}.stream"
     ))
     .await?
     .compat();
diff --git a/tests/it/io/parquet/read.rs b/tests/it/io/parquet/read.rs
index 233560398f..a07c394bc4 100644
--- a/tests/it/io/parquet/read.rs
+++ b/tests/it/io/parquet/read.rs
@@ -19,14 +19,13 @@ fn test_pyarrow_integration(
     }
     let use_dict = if use_dict { "dict/" } else { "" };
     let compression = if let Some(compression) = compression {
-        format!("{}/", compression)
+        format!("{compression}/")
     } else {
         "".to_string()
     };
     let required_str = if required { "required" } else { "nullable" };
     let path = format!(
-        "fixtures/pyarrow3/v{}/{}{}{}_{}_10.parquet",
-        version, use_dict, compression, type_, required_str
+        "fixtures/pyarrow3/v{version}/{use_dict}{compression}{type_}_{required_str}_10.parquet"
     );
 
     let mut file = File::open(path).unwrap();
@@ -610,8 +609,7 @@ fn invalid_utf8() -> Result<()> {
     let error = reader.collect::<Result<Vec<_>>>().unwrap_err();
     assert!(
         error.to_string().contains("invalid utf-8"),
-        "unexpected error: {}",
-        error
+        "unexpected error: {error}"
     );
     Ok(())
 }
diff --git a/tests/it/io/print.rs b/tests/it/io/print.rs
index 206d33f181..8cbc15a95f 100644
--- a/tests/it/io/print.rs
+++ b/tests/it/io/print.rs
@@ -30,7 +30,7 @@ fn write_basics() -> Result<()> {
 
     let actual: Vec<&str> = table.lines().collect();
 
-    assert_eq!(expected, actual, "Actual result:\n{}", table);
+    assert_eq!(expected, actual, "Actual result:\n{table}");
 
     Ok(())
 }
@@ -61,7 +61,7 @@ fn write_null() -> Result<()> {
 
     let actual: Vec<&str> = table.lines().collect();
 
-    assert_eq!(expected, actual, "Actual result:\n{:#?}", table);
+    assert_eq!(expected, actual, "Actual result:\n{table:#?}");
     Ok(())
 }
 
@@ -88,7 +88,7 @@ fn write_dictionary() -> Result<()> {
 
     let actual: Vec<&str> = table.lines().collect();
 
-    assert_eq!(expected, actual, "Actual result:\n{}", table);
+    assert_eq!(expected, actual, "Actual result:\n{table}");
 
     Ok(())
 }
@@ -109,7 +109,7 @@ fn dictionary_validities() -> Result<()> {
 
     let actual: Vec<&str> = table.lines().collect();
 
-    assert_eq!(expected, actual, "Actual result:\n{}", table);
+    assert_eq!(expected, actual, "Actual result:\n{table}");
 
     Ok(())
 }
@@ -345,7 +345,7 @@ fn write_struct() -> Result<()> {
 
     let actual: Vec<&str> = table.lines().collect();
 
-    assert_eq!(expected, actual, "Actual result:\n{}", table);
+    assert_eq!(expected, actual, "Actual result:\n{table}");
 
     Ok(())
 }
@@ -375,7 +375,7 @@ fn write_union() -> Result<()> {
 
     let actual: Vec<&str> = table.lines().collect();
 
-    assert_eq!(expected, actual, "Actual result:\n{}", table);
+    assert_eq!(expected, actual, "Actual result:\n{table}");
 
     Ok(())
 }
diff --git a/tests/it/temporal_conversions.rs b/tests/it/temporal_conversions.rs
index 91dd1ba8ef..fcccc546b4 100644
--- a/tests/it/temporal_conversions.rs
+++ b/tests/it/temporal_conversions.rs
@@ -13,7 +13,7 @@ fn naive() {
         "1996-12-19 13:39:57-03:00", // missing T
     ]);
     let r = temporal_conversions::utf8_to_naive_timestamp_ns(&array, fmt);
-    assert_eq!(format!("{:?}", r), expected);
+    assert_eq!(format!("{r:?}"), expected);
 
     let fmt = "%Y-%m-%dT%H:%M:%S"; // no tz info
     let array = Utf8Array::<i32>::from_slice([
@@ -22,7 +22,7 @@ fn naive() {
         "1996-12-19 13:39:57-03:00", // missing T
     ]);
     let r = temporal_conversions::utf8_to_naive_timestamp_ns(&array, fmt);
-    assert_eq!(format!("{:?}", r), expected);
+    assert_eq!(format!("{r:?}"), expected);
 }
 
 #[test]
@@ -35,7 +35,7 @@ fn naive_no_tz() {
         "1996-12-19 13:39:57", // missing T
     ]);
     let r = temporal_conversions::utf8_to_naive_timestamp_ns(&array, fmt);
-    assert_eq!(format!("{:?}", r), expected);
+    assert_eq!(format!("{r:?}"), expected);
 }
 
 #[test]
@@ -50,7 +50,7 @@ fn tz_aware() {
         "1996-12-19 13:39:57.0-03:00",
     ]);
     let r = temporal_conversions::utf8_to_timestamp_ns(&array, fmt, tz).unwrap();
-    assert_eq!(format!("{:?}", r), expected);
+    assert_eq!(format!("{r:?}"), expected);
 }
 
 #[test]
@@ -64,7 +64,7 @@ fn tz_aware_no_timezone() {
         "1996-12-19 13:39:57.0",
     ]);
     let r = temporal_conversions::utf8_to_timestamp_ns(&array, fmt, tz).unwrap();
-    assert_eq!(format!("{:?}", r), expected);
+    assert_eq!(format!("{r:?}"), expected);
 }
 
 #[test]
@@ -81,7 +81,7 @@ fn add_interval_fixed_offset() {
         &timezone,
     );
     let r = temporal_conversions::timestamp_to_datetime(r, timeunit, &timezone);
-    assert_eq!("1972-02-29 02:01:00 +01:00", format!("{}", r));
+    assert_eq!("1972-02-29 02:01:00 +01:00", format!("{r}"));
 
     let r = temporal_conversions::add_interval(
         timestamp,
@@ -90,7 +90,7 @@ fn add_interval_fixed_offset() {
         &timezone,
     );
     let r = temporal_conversions::timestamp_to_datetime(r, timeunit, &timezone);
-    assert_eq!("1972-03-29 02:01:00 +01:00", format!("{}", r));
+    assert_eq!("1972-03-29 02:01:00 +01:00", format!("{r}"));
 
     let r = temporal_conversions::add_interval(
         timestamp,
@@ -99,7 +99,7 @@ fn add_interval_fixed_offset() {
         &timezone,
     );
     let r = temporal_conversions::timestamp_to_datetime(r, timeunit, &timezone);
-    assert_eq!("1974-03-01 02:01:00 +01:00", format!("{}", r));
+    assert_eq!("1974-03-01 02:01:00 +01:00", format!("{r}"));
 
     let r = temporal_conversions::add_interval(
         timestamp,
@@ -108,7 +108,7 @@ fn add_interval_fixed_offset() {
         &timezone,
     );
     let r = temporal_conversions::timestamp_to_datetime(r, timeunit, &timezone);
-    assert_eq!("1972-01-29 02:01:00 +01:00", format!("{}", r));
+    assert_eq!("1972-01-29 02:01:00 +01:00", format!("{r}"));
 }
 
 #[cfg(feature = "chrono-tz")]
@@ -127,7 +127,7 @@ fn add_interval_timezone() {
         &timezone,
     );
     let r = temporal_conversions::timestamp_to_datetime(r, timeunit, &timezone);
-    assert_eq!("2020-03-29 02:00:00 WEST", format!("{}", r));
+    assert_eq!("2020-03-29 02:00:00 WEST", format!("{r}"));
 
     // crosses two summer time changes and thus adds only 1 hour
     let r = temporal_conversions::add_interval(
@@ -137,5 +137,5 @@ fn add_interval_timezone() {
         &timezone,
     );
     let r = temporal_conversions::timestamp_to_datetime(r, timeunit, &timezone);
-    assert_eq!("2020-10-29 01:00:00 WET", format!("{}", r));
+    assert_eq!("2020-10-29 01:00:00 WET", format!("{r}"));
 }