diff --git a/arrow/src/array/data.rs b/arrow/src/array/data.rs
index 7ae3858..9d5b0ee 100644
--- a/arrow/src/array/data.rs
+++ b/arrow/src/array/data.rs
@@ -500,6 +500,7 @@
     }
 
     #[inline]
+    #[allow(clippy::len_without_is_empty)]
     pub const fn len(mut self, n: usize) -> Self {
         self.len = n;
         self
diff --git a/arrow/src/compute/kernels/regexp.rs b/arrow/src/compute/kernels/regexp.rs
index 446d71d..5093dce 100644
--- a/arrow/src/compute/kernels/regexp.rs
+++ b/arrow/src/compute/kernels/regexp.rs
@@ -82,10 +82,8 @@
                     };
                     match re.captures(value) {
                         Some(caps) => {
-                            for m in caps.iter().skip(1) {
-                                if let Some(v) = m {
-                                    list_builder.values().append_value(v.as_str())?;
-                                }
+                            for m in caps.iter().skip(1).flatten() {
+                                list_builder.values().append_value(m.as_str())?;
                             }
                             list_builder.append(true)?
                         }
diff --git a/arrow/src/json/reader.rs b/arrow/src/json/reader.rs
index 31c496c..d0b9c19 100644
--- a/arrow/src/json/reader.rs
+++ b/arrow/src/json/reader.rs
@@ -654,7 +654,7 @@
             projection
                 .iter()
                 .map(|name| self.schema.column_with_name(name))
-                .filter_map(|c| c)
+                .flatten()
                 .map(|(_, field)| field.clone())
                 .collect()
         };
diff --git a/parquet/src/arrow/array_reader.rs b/parquet/src/arrow/array_reader.rs
index 943820f..d125cf6 100644
--- a/parquet/src/arrow/array_reader.rs
+++ b/parquet/src/arrow/array_reader.rs
@@ -1405,11 +1405,9 @@
             self.file_reader.clone(),
         )?);
 
-        let arrow_type: Option<ArrowType> = match self.get_arrow_field(&cur_type, context)
-        {
-            Some(f) => Some(f.data_type().clone()),
-            _ => None,
-        };
+        let arrow_type: Option<ArrowType> = self
+            .get_arrow_field(&cur_type, context)
+            .map(|f| f.data_type().clone());
 
         match cur_type.get_physical_type() {
             PhysicalType::BOOLEAN => Ok(Box::new(PrimitiveArrayReader::<BoolType>::new(
diff --git a/parquet/src/arrow/schema.rs b/parquet/src/arrow/schema.rs
index b15bb7e..6c04b70 100644
--- a/parquet/src/arrow/schema.rs
+++ b/parquet/src/arrow/schema.rs
@@ -172,7 +172,7 @@
             FieldType::Arrow(f) => Ok(Some(f)),
         })
         .collect::<Result<Vec<Option<Field>>>>()
-        .map(|result| result.into_iter().filter_map(|f| f).collect::<Vec<Field>>())
+        .map(|result| result.into_iter().flatten().collect::<Vec<Field>>())
         .map(|fields| Schema::new_with_metadata(fields, metadata))
 }
 
@@ -827,9 +827,7 @@
                 .iter()
                 .map(|field_ptr| self.clone_with_schema(field_ptr).to_field())
                 .collect::<Result<Vec<Option<Field>>>>()
-                .map(|result| {
-                    result.into_iter().filter_map(|f| f).collect::<Vec<Field>>()
-                })
+                .map(|result| result.into_iter().flatten().collect::<Vec<Field>>())
                 .map(|fields| {
                     if fields.is_empty() {
                         None
diff --git a/parquet/src/schema/parser.rs b/parquet/src/schema/parser.rs
index 3ce347c..41f6290 100644
--- a/parquet/src/schema/parser.rs
+++ b/parquet/src/schema/parser.rs
@@ -372,15 +372,15 @@
                                 )?;
                                 assert_token(self.tokenizer.next(), ")")?;
                                 logical = Some(LogicalType::DECIMAL(DecimalType {
-                                    precision,
                                     scale,
+                                    precision,
                                 }));
                                 converted = ConvertedType::from(logical.clone());
                             } else {
                                 scale = 0;
                                 logical = Some(LogicalType::DECIMAL(DecimalType {
-                                    precision,
                                     scale,
+                                    precision,
                                 }));
                                 converted = ConvertedType::from(logical.clone());
                             }
@@ -401,8 +401,8 @@
                                 )?;
                                 assert_token(self.tokenizer.next(), ")")?;
                                 logical = Some(LogicalType::TIME(TimeType {
-                                    unit,
                                     is_adjusted_to_u_t_c,
+                                    unit,
                                 }));
                                 converted = ConvertedType::from(logical.clone());
                             } else {
@@ -426,8 +426,8 @@
                                 )?;
                                 assert_token(self.tokenizer.next(), ")")?;
                                 logical = Some(LogicalType::TIMESTAMP(TimestampType {
-                                    unit,
                                     is_adjusted_to_u_t_c,
+                                    unit,
                                 }));
                                 converted = ConvertedType::from(logical.clone());
                             } else {