diff --git a/examples/parquet.rs b/examples/parquet.rs
index 9ad7a2d..a263c6f 100644
--- a/examples/parquet.rs
+++ b/examples/parquet.rs
@@ -78,7 +78,7 @@ fn main() {
     let output = narrow_array.clone().into_iter().collect::<Vec<_>>();
     assert_eq!(input.as_slice(), output);
 
-    let record_batch = RecordBatch::from(narrow_array);
+    let record_batch: RecordBatch = narrow_array.into();
     println!("From narrow StructArray to Arrow RecordBatch");
     pretty::print_batches(&[record_batch.clone()]).unwrap();
 
@@ -94,7 +94,7 @@ fn main() {
     assert_eq!(record_batch, read.clone());
 
     let round_trip: StructArray<Foo, NonNullable, ScalarBuffer> = read.into();
-    let arrow_struct_array_round_trip = arrow_array::StructArray::from(round_trip);
+    let arrow_struct_array_round_trip: arrow_array::StructArray = round_trip.into();
     let record_batch_round_trip = arrow_array::RecordBatch::from(arrow_struct_array_round_trip);
     println!(
         "From Arrow RecordBatch (via Parquet) to narrow StructArray and back to Arrow RecordBatch"
diff --git a/narrow-derive/src/enum.rs b/narrow-derive/src/enum.rs
index 3789dc4..02f53d1 100644
--- a/narrow-derive/src/enum.rs
+++ b/narrow-derive/src/enum.rs
@@ -1087,13 +1087,11 @@ impl<'a> Enum<'a> {
         let (_, self_ty_generics, _) = self.generics.split_for_impl();
         generics.make_where_clause().predicates.extend(
             self.variant_indices().map::<WherePredicate, _>(|idx| {
-                parse_quote!(::std::sync::Arc<dyn ::arrow_array::Array>: From<
-                <<#self_ident #self_ty_generics as #narrow::array::union::EnumVariant<#idx>>::Data as #narrow::array::ArrayType<<#self_ident #self_ty_generics as #narrow::array::union::EnumVariant<#idx>>::Data>>::Array<
+                parse_quote!(<<#self_ident #self_ty_generics as #narrow::array::union::EnumVariant<#idx>>::Data as #narrow::array::ArrayType<<#self_ident #self_ty_generics as #narrow::array::union::EnumVariant<#idx>>::Data>>::Array<
                     Buffer,
                     OffsetItem,
                     UnionLayout,
-                >,
-            >)
+                >: Into<::std::sync::Arc<dyn ::arrow_array::Array>>)
             }),
         );
 
@@ -1101,11 +1099,11 @@ impl<'a> Enum<'a> {
         let (_, ty_generics, _) = generics.split_for_impl();
         let idx = self.variant_indices();
         let tokens = quote! {
-            impl #impl_generics ::std::convert::From<#ident #ty_generics> for ::std::vec::Vec<::std::sync::Arc<dyn ::arrow_array::Array>> #where_clause {
-                fn from(value: #ident #ty_generics) -> Self {
+            impl #impl_generics ::std::convert::Into<::std::vec::Vec<::std::sync::Arc<dyn ::arrow_array::Array>>> for #ident #ty_generics #where_clause {
+                fn into(self) -> ::std::vec::Vec<::std::sync::Arc<dyn ::arrow_array::Array>> {
                     vec![
                         #(
-                            value.#idx.into(),
+                            self.#idx.into(),
                         )*
                     ]
                 }
diff --git a/narrow-derive/src/struct.rs b/narrow-derive/src/struct.rs
index e43fc81..505cf93 100644
--- a/narrow-derive/src/struct.rs
+++ b/narrow-derive/src/struct.rs
@@ -332,7 +332,7 @@ impl Struct<'_> {
                 let field_ident = self.field_idents();
                 quote!(
                     #(
-                        value.#field_ident.into(),
+                        self.#field_ident.into(),
                     )*
                 )
             }
@@ -344,19 +344,20 @@ impl Struct<'_> {
                     .map(|(idx, _)| Index::from(idx));
                 quote!(
                     #(
-                        value.#field_idx.into(),
+                        self.#field_idx.into(),
                     )*
                 )
             }
             Fields::Unit => {
-                quote!(value.0.into())
+                quote!(self.0.into())
             }
         };
 
         let ident = self.array_struct_ident();
         let tokens = quote! {
-            impl #impl_generics ::std::convert::From<#ident #ty_generics> for ::std::vec::Vec<::std::sync::Arc<dyn ::arrow_array::Array>> #where_clause  {
-                fn from(value: #ident #ty_generics) -> Self {
+            #[allow(clippy::from_over_into)]
+            impl #impl_generics std::convert::Into<::std::vec::Vec<::std::sync::Arc<dyn ::arrow_array::Array>>> for #ident #ty_generics #where_clause  {
+                fn into(self) -> ::std::vec::Vec<::std::sync::Arc<dyn ::arrow_array::Array>> {
                     vec![
                         #field_arrays
                     ]
diff --git a/src/arrow/array/boolean.rs b/src/arrow/array/boolean.rs
index 25bea53..73f4c7b 100644
--- a/src/arrow/array/boolean.rs
+++ b/src/arrow/array/boolean.rs
@@ -23,32 +23,35 @@ impl<Nullable: Nullability, Buffer: BufferType> crate::arrow::Array
     }
 }
 
-impl<Buffer: BufferType> From<BooleanArray<NonNullable, Buffer>> for arrow_array::BooleanArray
+#[allow(clippy::from_over_into)]
+impl<Buffer: BufferType> Into<arrow_array::BooleanArray> for BooleanArray<NonNullable, Buffer>
 where
-    arrow_buffer::BooleanBuffer: From<Bitmap<Buffer>>,
+    Bitmap<Buffer>: Into<arrow_buffer::BooleanBuffer>,
 {
-    fn from(value: BooleanArray<NonNullable, Buffer>) -> Self {
-        arrow_array::BooleanArray::new(value.0.into(), None)
+    fn into(self) -> arrow_array::BooleanArray {
+        arrow_array::BooleanArray::new(self.0.into(), None)
     }
 }
 
-impl<Buffer: BufferType> From<BooleanArray<Nullable, Buffer>> for arrow_array::BooleanArray
+#[allow(clippy::from_over_into)]
+impl<Buffer: BufferType> Into<arrow_array::BooleanArray> for BooleanArray<Nullable, Buffer>
 where
-    arrow_buffer::BooleanBuffer: From<Bitmap<Buffer>>,
-    arrow_buffer::NullBuffer: From<Bitmap<Buffer>>,
+    Bitmap<Buffer>: Into<arrow_buffer::BooleanBuffer>,
+    Bitmap<Buffer>: Into<arrow_buffer::NullBuffer>,
 {
-    fn from(value: BooleanArray<Nullable, Buffer>) -> Self {
-        arrow_array::BooleanArray::new(value.0.data.into(), Some(value.0.validity.into()))
+    fn into(self) -> arrow_array::BooleanArray {
+        arrow_array::BooleanArray::new(self.0.data.into(), Some(self.0.validity.into()))
     }
 }
 
-impl<Nullable: Nullability, Buffer: BufferType> From<BooleanArray<Nullable, Buffer>>
-    for Arc<dyn arrow_array::Array>
+#[allow(clippy::from_over_into)]
+impl<Nullable: Nullability, Buffer: BufferType> Into<Arc<dyn arrow_array::Array>>
+    for BooleanArray<Nullable, Buffer>
 where
-    arrow_array::BooleanArray: From<BooleanArray<Nullable, Buffer>>,
+    BooleanArray<Nullable, Buffer>: Into<arrow_array::BooleanArray>,
 {
-    fn from(value: BooleanArray<Nullable, Buffer>) -> Self {
-        Arc::new(arrow_array::BooleanArray::from(value))
+    fn into(self) -> Arc<dyn arrow_array::Array> {
+        Arc::new(self.into())
     }
 }
 
diff --git a/src/arrow/array/fixed_size_binary.rs b/src/arrow/array/fixed_size_binary.rs
index 7b7a72d..abffcab 100644
--- a/src/arrow/array/fixed_size_binary.rs
+++ b/src/arrow/array/fixed_size_binary.rs
@@ -44,12 +44,13 @@ where
     }
 }
 
-impl<const N: usize, Buffer: BufferType> From<FixedSizeBinaryArray<N, NonNullable, Buffer>>
-    for arrow_array::FixedSizeBinaryArray
+#[allow(clippy::from_over_into)]
+impl<const N: usize, Buffer: BufferType> Into<arrow_array::FixedSizeBinaryArray>
+    for FixedSizeBinaryArray<N, NonNullable, Buffer>
 where
-    arrow_buffer::Buffer: From<FixedSizePrimitiveArray<u8, NonNullable, Buffer>>,
+    FixedSizePrimitiveArray<u8, NonNullable, Buffer>: Into<arrow_buffer::Buffer>,
 {
-    fn from(value: FixedSizeBinaryArray<N, NonNullable, Buffer>) -> Self {
+    fn into(self) -> arrow_array::FixedSizeBinaryArray {
         // todo(mbrobbel): const_assert
         assert!(N <= 0x7FFF_FFFF); // i32::MAX
         #[allow(
@@ -59,29 +60,31 @@ where
         )]
         arrow_array::FixedSizeBinaryArray::new(
             i32::try_from(N).expect("overflow"),
-            value.0 .0.into(),
+            self.0 .0.into(),
             None,
         )
     }
 }
 
-impl<Nullable: Nullability, const N: usize, Buffer: BufferType>
-    From<FixedSizeBinaryArray<N, Nullable, Buffer>> for Arc<dyn arrow_array::Array>
+#[allow(clippy::from_over_into)]
+impl<Nullable: Nullability, const N: usize, Buffer: BufferType> Into<Arc<dyn arrow_array::Array>>
+    for FixedSizeBinaryArray<N, Nullable, Buffer>
 where
-    arrow_array::FixedSizeBinaryArray: From<FixedSizeBinaryArray<N, Nullable, Buffer>>,
+    FixedSizeBinaryArray<N, Nullable, Buffer>: Into<arrow_array::FixedSizeBinaryArray>,
 {
-    fn from(value: FixedSizeBinaryArray<N, Nullable, Buffer>) -> Self {
-        Arc::new(arrow_array::FixedSizeBinaryArray::from(value))
+    fn into(self) -> Arc<dyn arrow_array::Array> {
+        Arc::new(self.into())
     }
 }
 
-impl<const N: usize, Buffer: BufferType> From<FixedSizeBinaryArray<N, Nullable, Buffer>>
-    for arrow_array::FixedSizeBinaryArray
+#[allow(clippy::from_over_into)]
+impl<const N: usize, Buffer: BufferType> Into<arrow_array::FixedSizeBinaryArray>
+    for FixedSizeBinaryArray<N, Nullable, Buffer>
 where
-    arrow_buffer::Buffer: From<FixedSizePrimitiveArray<u8, NonNullable, Buffer>>,
+    FixedSizePrimitiveArray<u8, NonNullable, Buffer>: Into<arrow_buffer::Buffer>,
     Bitmap<Buffer>: Into<NullBuffer>,
 {
-    fn from(value: FixedSizeBinaryArray<N, Nullable, Buffer>) -> Self {
+    fn into(self) -> arrow_array::FixedSizeBinaryArray {
         // todo(mbrobbel): const_assert
         assert!(N <= 0x7FFF_FFFF); // i32::MAX
         #[allow(
@@ -91,8 +94,8 @@ where
         )]
         arrow_array::FixedSizeBinaryArray::new(
             i32::try_from(N).expect("overflow"),
-            value.0 .0.data.into(),
-            Some(value.0 .0.validity.into()),
+            self.0 .0.data.into(),
+            Some(self.0 .0.validity.into()),
         )
     }
 }
@@ -148,7 +151,7 @@ mod tests {
     fn from() {
         let fixed_size_binary_array = INPUT.into_iter().collect::<FixedSizeBinaryArray<2>>();
         assert_eq!(
-            arrow_array::FixedSizeBinaryArray::from(fixed_size_binary_array)
+            Into::<arrow_array::FixedSizeBinaryArray>::into(fixed_size_binary_array)
                 .iter()
                 .flatten()
                 .flatten()
@@ -161,7 +164,7 @@ mod tests {
             .into_iter()
             .collect::<FixedSizeBinaryArray<2, Nullable>>();
         assert_eq!(
-            arrow_array::FixedSizeBinaryArray::from(fixed_size_binary_array_nullable)
+            Into::<arrow_array::FixedSizeBinaryArray>::into(fixed_size_binary_array_nullable)
                 .iter()
                 .flatten()
                 .flatten()
@@ -206,7 +209,7 @@ mod tests {
             .into_iter()
             .collect::<FixedSizeBinaryArray<2, Nullable>>();
         let fixed_size_binary_array_nullable =
-            arrow_array::FixedSizeBinaryArray::from(fixed_size_binary_array_nullable_input);
+            Into::<arrow_array::FixedSizeBinaryArray>::into(fixed_size_binary_array_nullable_input);
         assert_eq!(
             FixedSizeBinaryArray::<2, Nullable>::from(fixed_size_binary_array_nullable)
                 .into_iter()
diff --git a/src/arrow/array/fixed_size_list.rs b/src/arrow/array/fixed_size_list.rs
index eef373c..aac6df0 100644
--- a/src/arrow/array/fixed_size_list.rs
+++ b/src/arrow/array/fixed_size_list.rs
@@ -48,43 +48,46 @@ where
     }
 }
 
-impl<const N: usize, T: Array, Buffer: BufferType>
-    From<FixedSizeListArray<N, T, NonNullable, Buffer>> for Arc<dyn arrow_array::Array>
+#[allow(clippy::from_over_into)]
+impl<const N: usize, T: Array, Buffer: BufferType> Into<Arc<dyn arrow_array::Array>>
+    for FixedSizeListArray<N, T, NonNullable, Buffer>
 where
     T: crate::arrow::Array + Into<Arc<dyn arrow_array::Array>>,
 {
-    fn from(value: FixedSizeListArray<N, T, NonNullable, Buffer>) -> Self {
+    fn into(self) -> Arc<dyn arrow_array::Array> {
         Arc::new(arrow_array::FixedSizeListArray::new(
             Arc::new(T::as_field("item")),
             i32::try_from(N).expect("overflow"),
-            value.0.into(),
+            self.0.into(),
             None,
         ))
     }
 }
 
-impl<const N: usize, T: Array, Buffer: BufferType> From<FixedSizeListArray<N, T, Nullable, Buffer>>
-    for Arc<dyn arrow_array::Array>
+#[allow(clippy::from_over_into)]
+impl<const N: usize, T: Array, Buffer: BufferType> Into<Arc<dyn arrow_array::Array>>
+    for FixedSizeListArray<N, T, Nullable, Buffer>
 where
     T: crate::arrow::Array + Into<Arc<dyn arrow_array::Array>>,
     Bitmap<Buffer>: Into<NullBuffer>,
 {
-    fn from(value: FixedSizeListArray<N, T, Nullable, Buffer>) -> Self {
+    fn into(self) -> Arc<dyn arrow_array::Array> {
         Arc::new(arrow_array::FixedSizeListArray::new(
             Arc::new(T::as_field("item")),
             i32::try_from(N).expect("overflow"),
-            value.0.data.into(),
-            Some(value.0.validity.into()),
+            self.0.data.into(),
+            Some(self.0.validity.into()),
         ))
     }
 }
 
+#[allow(clippy::from_over_into)]
 impl<const N: usize, T: crate::arrow::Array, Buffer: BufferType>
-    From<FixedSizeListArray<N, T, NonNullable, Buffer>> for arrow_array::FixedSizeListArray
+    Into<arrow_array::FixedSizeListArray> for FixedSizeListArray<N, T, NonNullable, Buffer>
 where
-    <T as crate::arrow::Array>::Array: From<T> + 'static,
+    T: Into<<T as crate::arrow::Array>::Array> + 'static,
 {
-    fn from(value: FixedSizeListArray<N, T, NonNullable, Buffer>) -> Self {
+    fn into(self) -> arrow_array::FixedSizeListArray {
         // todo(mbrobbel): const_assert
         assert!(N <= 0x7FFF_FFFF); // i32::MAX
         #[allow(
@@ -95,19 +98,20 @@ where
         arrow_array::FixedSizeListArray::new(
             Arc::new(T::as_field("item")),
             i32::try_from(N).expect("overflow"),
-            Arc::<<T as crate::arrow::Array>::Array>::new(value.0.into()),
+            Arc::<<T as crate::arrow::Array>::Array>::new(self.0.into()),
             None,
         )
     }
 }
 
+#[allow(clippy::from_over_into)]
 impl<const N: usize, T: crate::arrow::Array, Buffer: BufferType>
-    From<FixedSizeListArray<N, T, Nullable, Buffer>> for arrow_array::FixedSizeListArray
+    Into<arrow_array::FixedSizeListArray> for FixedSizeListArray<N, T, Nullable, Buffer>
 where
-    <T as crate::arrow::Array>::Array: From<T> + 'static,
+    T: Into<<T as crate::arrow::Array>::Array> + 'static,
     Bitmap<Buffer>: Into<NullBuffer>,
 {
-    fn from(value: FixedSizeListArray<N, T, Nullable, Buffer>) -> Self {
+    fn into(self) -> arrow_array::FixedSizeListArray {
         // todo(mbrobbel): const_assert
         assert!(N <= 0x7FFF_FFFF); // i32::MAX
         #[allow(
@@ -118,8 +122,8 @@ where
         arrow_array::FixedSizeListArray::new(
             Arc::new(T::as_field("item")),
             i32::try_from(N).expect("overflow"),
-            Arc::<<T as crate::arrow::Array>::Array>::new(value.0.data.into()),
-            Some(value.0.validity.into()),
+            Arc::<<T as crate::arrow::Array>::Array>::new(self.0.data.into()),
+            Some(self.0.validity.into()),
         )
     }
 }
@@ -183,7 +187,7 @@ mod tests {
             .into_iter()
             .collect::<FixedSizeListArray<2, Uint32Array>>();
         assert_eq!(
-            arrow_array::FixedSizeListArray::from(fixed_size_list_array)
+            Into::<arrow_array::FixedSizeListArray>::into(fixed_size_list_array)
                 .iter()
                 .flatten()
                 .flat_map(|dyn_array| {
@@ -199,7 +203,7 @@ mod tests {
             .into_iter()
             .collect::<FixedSizeListArray<2, StringArray, Nullable>>();
         assert_eq!(
-            arrow_array::FixedSizeListArray::from(fixed_size_list_array_nullable)
+            Into::<arrow_array::FixedSizeListArray>::into(fixed_size_list_array_nullable)
                 .iter()
                 .flatten()
                 .flat_map(|dyn_array| {
@@ -281,8 +285,8 @@ mod tests {
         let fixed_size_list_array_nullable_input = INPUT_NULLABLE
             .into_iter()
             .collect::<FixedSizeListArray<2, StringArray, Nullable>>();
-        let fixed_size_list_array_nullable =
-            arrow_array::FixedSizeListArray::from(fixed_size_list_array_nullable_input);
+        let fixed_size_list_array_nullable: arrow_array::FixedSizeListArray =
+            fixed_size_list_array_nullable_input.into();
 
         assert_eq!(
             FixedSizeListArray::<
diff --git a/src/arrow/array/fixed_size_primitive.rs b/src/arrow/array/fixed_size_primitive.rs
index a98137a..8eed264 100644
--- a/src/arrow/array/fixed_size_primitive.rs
+++ b/src/arrow/array/fixed_size_primitive.rs
@@ -9,7 +9,6 @@ use arrow_array::{
     },
     Array as _,
 };
-use arrow_buffer::ScalarBuffer;
 
 use crate::{
     array::FixedSizePrimitiveArray,
@@ -71,39 +70,43 @@ impl<Nullable: Nullability, T: FixedSize + FixedSizeExt, Buffer: BufferType> cra
     }
 }
 
+#[allow(clippy::from_over_into)]
 impl<T: FixedSize, U: arrow_array::types::ArrowPrimitiveType<Native = T>, Buffer: BufferType>
-    From<FixedSizePrimitiveArray<T, NonNullable, Buffer>> for arrow_array::PrimitiveArray<U>
+    Into<arrow_array::PrimitiveArray<U>> for FixedSizePrimitiveArray<T, NonNullable, Buffer>
 where
-    arrow_buffer::ScalarBuffer<T>: From<<Buffer as BufferType>::Buffer<T>>,
+    <Buffer as BufferType>::Buffer<T>: Into<arrow_buffer::ScalarBuffer<T>>,
 {
-    fn from(value: FixedSizePrimitiveArray<T, NonNullable, Buffer>) -> Self {
-        arrow_array::PrimitiveArray::new(value.0.into(), None)
+    fn into(self) -> arrow_array::PrimitiveArray<U> {
+        arrow_array::PrimitiveArray::new(self.0.into(), None)
     }
 }
 
+#[allow(clippy::from_over_into)]
 impl<T: FixedSize, U: arrow_array::types::ArrowPrimitiveType<Native = T>, Buffer: BufferType>
-    From<FixedSizePrimitiveArray<T, Nullable, Buffer>> for arrow_array::PrimitiveArray<U>
+    Into<arrow_array::PrimitiveArray<U>> for FixedSizePrimitiveArray<T, Nullable, Buffer>
 where
-    arrow_buffer::ScalarBuffer<T>: From<<Buffer as BufferType>::Buffer<T>>,
-    arrow_buffer::NullBuffer: From<Bitmap<Buffer>>,
+    <Buffer as BufferType>::Buffer<T>: Into<arrow_buffer::ScalarBuffer<T>>,
+    Bitmap<Buffer>: Into<arrow_buffer::NullBuffer>,
 {
-    fn from(value: FixedSizePrimitiveArray<T, Nullable, Buffer>) -> Self {
-        arrow_array::PrimitiveArray::new(value.0.data.into(), Some(value.0.validity.into()))
+    fn into(self) -> arrow_array::PrimitiveArray<U> {
+        arrow_array::PrimitiveArray::new(self.0.data.into(), Some(self.0.validity.into()))
     }
 }
 
-impl<T: FixedSizeExt, Nullable: Nullability, Buffer: BufferType>
-    From<FixedSizePrimitiveArray<T, Nullable, Buffer>> for Arc<dyn arrow_array::Array>
+#[allow(clippy::from_over_into)]
+impl<T: FixedSizeExt, Nullable: Nullability, Buffer: BufferType> Into<Arc<dyn arrow_array::Array>>
+    for FixedSizePrimitiveArray<T, Nullable, Buffer>
 where
-    arrow_array::PrimitiveArray<<T as FixedSizeExt>::ArrowPrimitiveType>:
-        From<FixedSizePrimitiveArray<T, Nullable, Buffer>>,
+    FixedSizePrimitiveArray<T, Nullable, Buffer>:
+        Into<arrow_array::PrimitiveArray<<T as FixedSizeExt>::ArrowPrimitiveType>>,
 {
-    fn from(value: FixedSizePrimitiveArray<T, Nullable, Buffer>) -> Self {
-        Arc::new(arrow_array::PrimitiveArray::from(value))
+    fn into(self) -> Arc<dyn arrow_array::Array> {
+        Arc::new(self.into())
     }
 }
 
 /// Panics when there are nulls.
+#[allow(clippy::from_over_into)]
 impl<T: FixedSize, U: arrow_array::types::ArrowPrimitiveType<Native = T>, Buffer: BufferType>
     From<arrow_array::PrimitiveArray<U>> for FixedSizePrimitiveArray<T, NonNullable, Buffer>
 where
@@ -150,30 +153,32 @@ where
 impl<T: FixedSize, Buffer: BufferType> From<arrow_buffer::ScalarBuffer<T>>
     for FixedSizePrimitiveArray<T, NonNullable, Buffer>
 where
-    <Buffer as BufferType>::Buffer<T>: From<ScalarBuffer<T>>,
+    <Buffer as BufferType>::Buffer<T>: From<arrow_buffer::ScalarBuffer<T>>,
 {
     fn from(value: arrow_buffer::ScalarBuffer<T>) -> Self {
         Self(value.into())
     }
 }
 
-impl<T: FixedSize, Buffer: BufferType> From<FixedSizePrimitiveArray<T, NonNullable, Buffer>>
-    for ScalarBuffer<T>
+#[allow(clippy::from_over_into)]
+impl<T: FixedSize, Buffer: BufferType> Into<arrow_buffer::ScalarBuffer<T>>
+    for FixedSizePrimitiveArray<T, NonNullable, Buffer>
 where
-    <Buffer as BufferType>::Buffer<T>: Into<ScalarBuffer<T>>,
+    <Buffer as BufferType>::Buffer<T>: Into<arrow_buffer::ScalarBuffer<T>>,
 {
-    fn from(value: FixedSizePrimitiveArray<T, NonNullable, Buffer>) -> Self {
-        value.0.into()
+    fn into(self) -> arrow_buffer::ScalarBuffer<T> {
+        self.0.into()
     }
 }
 
-impl<T: FixedSize, Buffer: BufferType> From<FixedSizePrimitiveArray<T, NonNullable, Buffer>>
-    for arrow_buffer::Buffer
+#[allow(clippy::from_over_into)]
+impl<T: FixedSize, Buffer: BufferType> Into<arrow_buffer::Buffer>
+    for FixedSizePrimitiveArray<T, NonNullable, Buffer>
 where
     <Buffer as BufferType>::Buffer<T>: Into<arrow_buffer::Buffer>,
 {
-    fn from(value: FixedSizePrimitiveArray<T, NonNullable, Buffer>) -> Self {
-        value.0.into()
+    fn into(self) -> arrow_buffer::Buffer {
+        self.0.into()
     }
 }
 
diff --git a/src/arrow/array/logical.rs b/src/arrow/array/logical.rs
index 8735ef1..c2ba323 100644
--- a/src/arrow/array/logical.rs
+++ b/src/arrow/array/logical.rs
@@ -60,14 +60,15 @@ where
     }
 }
 
+#[allow(clippy::from_over_into)]
 impl<
         T: LogicalArrayType<T>,
         Nullable: Nullability,
         Buffer: BufferType,
         OffsetItem: Offset,
         UnionLayout: UnionType,
-    > From<LogicalArray<T, Nullable, Buffer, OffsetItem, UnionLayout>>
-    for Arc<dyn arrow_array::Array>
+    > Into<Arc<dyn arrow_array::Array>>
+    for LogicalArray<T, Nullable, Buffer, OffsetItem, UnionLayout>
 where
     Option<T>: ArrayType<T>,
     Nullable::Item<T::ArrayType>: ArrayType<T::ArrayType>,
@@ -77,59 +78,58 @@ where
         UnionLayout,
     >: Into<Arc<dyn arrow_array::Array>>,
 {
-    fn from(value: LogicalArray<T, Nullable, Buffer, OffsetItem, UnionLayout>) -> Self {
-        Arc::new(value.0.into())
+    fn into(self) -> Arc<dyn arrow_array::Array> {
+        Arc::new(self.0.into())
     }
 }
 
+#[allow(clippy::from_over_into)]
 impl<
         T: LogicalArrayType<T>,
         Nullable: Nullability,
         Buffer: BufferType,
         OffsetItem: Offset,
         UnionLayout: UnionType,
-    > From<LogicalArray<T, Nullable, Buffer, OffsetItem, UnionLayout>>
-    for arrow_array::FixedSizeListArray
+    > Into<arrow_array::FixedSizeListArray>
+    for LogicalArray<T, Nullable, Buffer, OffsetItem, UnionLayout>
 where
     Option<T>: ArrayType<T>,
     Nullable::Item<T::ArrayType>: ArrayType<T::ArrayType>,
-    arrow_array::FixedSizeListArray: From<
-        <Nullable::Item<T::ArrayType> as ArrayType<T::ArrayType>>::Array<
-            Buffer,
-            OffsetItem,
-            UnionLayout,
-        >,
-    >,
+    <Nullable::Item<T::ArrayType> as ArrayType<T::ArrayType>>::Array<
+        Buffer,
+        OffsetItem,
+        UnionLayout,
+    >: Into<arrow_array::FixedSizeListArray>,
 {
-    fn from(value: LogicalArray<T, Nullable, Buffer, OffsetItem, UnionLayout>) -> Self {
-        value.0.into()
+    fn into(self) -> arrow_array::FixedSizeListArray {
+        self.0.into()
     }
 }
 
+#[allow(clippy::from_over_into)]
 impl<
         T: LogicalArrayType<T>,
         Nullable: Nullability,
         Buffer: BufferType,
         OffsetItem: Offset,
         UnionLayout: UnionType,
-    > From<LogicalArray<T, Nullable, Buffer, OffsetItem, UnionLayout>>
-    for arrow_array::FixedSizeBinaryArray
+    > Into<arrow_array::FixedSizeBinaryArray>
+    for LogicalArray<T, Nullable, Buffer, OffsetItem, UnionLayout>
 where
     Option<T>: ArrayType<T>,
     Nullable::Item<T::ArrayType>: ArrayType<T::ArrayType>,
-    arrow_array::FixedSizeBinaryArray: From<
-        <Nullable::Item<T::ArrayType> as ArrayType<T::ArrayType>>::Array<
-            Buffer,
-            OffsetItem,
-            UnionLayout,
-        >,
-    >,
+    <Nullable::Item<T::ArrayType> as ArrayType<T::ArrayType>>::Array<
+        Buffer,
+        OffsetItem,
+        UnionLayout,
+    >: Into<arrow_array::FixedSizeBinaryArray>,
 {
-    fn from(value: LogicalArray<T, Nullable, Buffer, OffsetItem, UnionLayout>) -> Self {
-        value.0.into()
+    fn into(self) -> arrow_array::FixedSizeBinaryArray {
+        self.0.into()
     }
 }
 
+#[allow(clippy::from_over_into)]
 impl<
         T: LogicalArrayType<T>,
         Nullable: Nullability,
@@ -137,21 +137,19 @@ impl<
         OffsetItem: Offset,
         UnionLayout: UnionType,
         O: OffsetSizeTrait,
-    > From<LogicalArray<T, Nullable, Buffer, OffsetItem, UnionLayout>>
-    for arrow_array::GenericListArray<O>
+    > Into<arrow_array::GenericListArray<O>>
+    for LogicalArray<T, Nullable, Buffer, OffsetItem, UnionLayout>
 where
     Option<T>: ArrayType<T>,
     Nullable::Item<T::ArrayType>: ArrayType<T::ArrayType>,
-    arrow_array::GenericListArray<O>: From<
-        <Nullable::Item<T::ArrayType> as ArrayType<T::ArrayType>>::Array<
-            Buffer,
-            OffsetItem,
-            UnionLayout,
-        >,
-    >,
+    <Nullable::Item<T::ArrayType> as ArrayType<T::ArrayType>>::Array<
+        Buffer,
+        OffsetItem,
+        UnionLayout,
+    >: Into<arrow_array::GenericListArray<O>>,
 {
-    fn from(value: LogicalArray<T, Nullable, Buffer, OffsetItem, UnionLayout>) -> Self {
-        value.0.into()
+    fn into(self) -> arrow_array::GenericListArray<O> {
+        self.0.into()
     }
 }
 
@@ -169,7 +167,7 @@ mod tests {
 
         let input = [Foo { items: None }];
         let array = input.into_iter().collect::<StructArray<Foo>>();
-        let record_batch = arrow_array::RecordBatch::from(array);
+        let record_batch: arrow_array::RecordBatch = array.into();
         assert_eq!(record_batch.num_rows(), 1);
     }
 }
diff --git a/src/arrow/array/null.rs b/src/arrow/array/null.rs
index 5df937f..0705861 100644
--- a/src/arrow/array/null.rs
+++ b/src/arrow/array/null.rs
@@ -35,21 +35,23 @@ where
     }
 }
 
-impl<T: Unit, Buffer: BufferType> From<NullArray<T, NonNullable, Buffer>>
-    for Arc<dyn arrow_array::Array>
+#[allow(clippy::from_over_into)]
+impl<T: Unit, Buffer: BufferType> Into<Arc<dyn arrow_array::Array>>
+    for NullArray<T, NonNullable, Buffer>
 where
-    arrow_array::NullArray: From<NullArray<T, NonNullable, Buffer>>,
+    NullArray<T, NonNullable, Buffer>: Into<arrow_array::NullArray>,
 {
-    fn from(value: NullArray<T, NonNullable, Buffer>) -> Self {
-        Arc::new(arrow_array::NullArray::from(value))
+    fn into(self) -> Arc<dyn arrow_array::Array> {
+        Arc::new(self.into())
     }
 }
 
-impl<T: Unit, Buffer: BufferType> From<NullArray<T, NonNullable, Buffer>>
-    for arrow_array::NullArray
+#[allow(clippy::from_over_into)]
+impl<T: Unit, Buffer: BufferType> Into<arrow_array::NullArray>
+    for NullArray<T, NonNullable, Buffer>
 {
-    fn from(value: NullArray<T, NonNullable, Buffer>) -> Self {
-        arrow_array::NullArray::new(value.len())
+    fn into(self) -> arrow_array::NullArray {
+        arrow_array::NullArray::new(self.len())
     }
 }
 
@@ -83,7 +85,7 @@ mod tests {
 
         let input = [Unit; 4];
         let array = input.into_iter().collect::<NullArray<Unit>>();
-        let arrow_array = arrow_array::NullArray::from(array);
+        let arrow_array: arrow_array::NullArray = array.into();
         assert!(arrow_array.data_type().is_null());
         let narrow_array = NullArray::<Unit>::from(arrow_array);
         assert_eq!(narrow_array.len(), 4);
@@ -92,7 +94,7 @@ mod tests {
         let array_nested = input_nested
             .into_iter()
             .collect::<StructArray<NestedUnit>>();
-        let arrow_array_nested = arrow_array::StructArray::from(array_nested);
+        let arrow_array_nested: arrow_array::StructArray = array_nested.into();
         assert!(arrow_array_nested
             .column(0)
             .as_struct()
diff --git a/src/arrow/array/string.rs b/src/arrow/array/string.rs
index 268b0a9..e83db38 100644
--- a/src/arrow/array/string.rs
+++ b/src/arrow/array/string.rs
@@ -46,63 +46,67 @@ where
     }
 }
 
-impl<OffsetItem: Offset + OffsetSizeTrait, Buffer: BufferType>
-    From<StringArray<NonNullable, OffsetItem, Buffer>> for Arc<dyn arrow_array::Array>
+#[allow(clippy::from_over_into)]
+impl<OffsetItem: Offset + OffsetSizeTrait, Buffer: BufferType> Into<Arc<dyn arrow_array::Array>>
+    for StringArray<NonNullable, OffsetItem, Buffer>
 where
     <Buffer as BufferType>::Buffer<OffsetItem>: Into<ScalarBuffer<OffsetItem>>,
     FixedSizePrimitiveArray<u8, NonNullable, Buffer>: Into<arrow_buffer::ScalarBuffer<u8>>,
 {
-    fn from(value: StringArray<NonNullable, OffsetItem, Buffer>) -> Self {
-        let array: arrow_array::GenericStringArray<OffsetItem> = value.into();
+    fn into(self) -> Arc<dyn arrow_array::Array> {
+        let array: arrow_array::GenericStringArray<OffsetItem> = self.into();
         Arc::new(array)
     }
 }
 
-impl<OffsetItem: Offset + OffsetSizeTrait, Buffer: BufferType>
-    From<StringArray<Nullable, OffsetItem, Buffer>> for Arc<dyn arrow_array::Array>
+#[allow(clippy::from_over_into)]
+impl<OffsetItem: Offset + OffsetSizeTrait, Buffer: BufferType> Into<Arc<dyn arrow_array::Array>>
+    for StringArray<Nullable, OffsetItem, Buffer>
 where
     <Buffer as BufferType>::Buffer<OffsetItem>: Into<ScalarBuffer<OffsetItem>>,
     FixedSizePrimitiveArray<u8, NonNullable, Buffer>: Into<arrow_buffer::ScalarBuffer<u8>>,
     Bitmap<Buffer>: Into<NullBuffer>,
 {
-    fn from(value: StringArray<Nullable, OffsetItem, Buffer>) -> Self {
-        let array: arrow_array::GenericStringArray<OffsetItem> = value.into();
+    fn into(self) -> Arc<dyn arrow_array::Array> {
+        let array: arrow_array::GenericStringArray<OffsetItem> = self.into();
         Arc::new(array)
     }
 }
 
+#[allow(clippy::from_over_into)]
 impl<OffsetItem: Offset + OffsetSizeTrait, Buffer: BufferType>
-    From<StringArray<NonNullable, OffsetItem, Buffer>>
-    for arrow_array::GenericStringArray<OffsetItem>
+    Into<arrow_array::GenericStringArray<OffsetItem>>
+    for StringArray<NonNullable, OffsetItem, Buffer>
 where
     <Buffer as BufferType>::Buffer<OffsetItem>: Into<ScalarBuffer<OffsetItem>>,
     FixedSizePrimitiveArray<u8, NonNullable, Buffer>: Into<arrow_buffer::ScalarBuffer<u8>>,
 {
-    fn from(value: StringArray<NonNullable, OffsetItem, Buffer>) -> Self {
+    fn into(self) -> arrow_array::GenericStringArray<OffsetItem> {
         arrow_array::GenericStringArray::new(
             // Safety:
             // - The narrow offfset buffer contains valid offset data
-            unsafe { OffsetBuffer::new_unchecked(value.0 .0.offsets.into()) },
-            value.0 .0.data.into().into_inner(),
+            unsafe { OffsetBuffer::new_unchecked(self.0 .0.offsets.into()) },
+            self.0 .0.data.into().into_inner(),
             None,
         )
     }
 }
 
+#[allow(clippy::from_over_into)]
 impl<OffsetItem: Offset + OffsetSizeTrait, Buffer: BufferType>
-    From<StringArray<Nullable, OffsetItem, Buffer>> for arrow_array::GenericStringArray<OffsetItem>
+    Into<arrow_array::GenericStringArray<OffsetItem>> for StringArray<Nullable, OffsetItem, Buffer>
 where
     <Buffer as BufferType>::Buffer<OffsetItem>: Into<ScalarBuffer<OffsetItem>>,
     FixedSizePrimitiveArray<u8, NonNullable, Buffer>: Into<arrow_buffer::ScalarBuffer<u8>>,
     Bitmap<Buffer>: Into<NullBuffer>,
 {
-    fn from(value: StringArray<Nullable, OffsetItem, Buffer>) -> Self {
+    fn into(self) -> arrow_array::GenericStringArray<OffsetItem> {
         arrow_array::GenericStringArray::new(
             // Safety:
             // - The narrow offfset buffer contains valid offset data
-            unsafe { OffsetBuffer::new_unchecked(value.0 .0.offsets.data.into()) },
-            value.0 .0.data.into().into_inner(),
-            Some(value.0 .0.offsets.validity.into()),
+            unsafe { OffsetBuffer::new_unchecked(self.0 .0.offsets.data.into()) },
+            self.0 .0.data.into().into_inner(),
+            Some(self.0 .0.offsets.validity.into()),
         )
     }
 }
@@ -168,7 +172,7 @@ mod tests {
     fn from() {
         let string_array = INPUT.into_iter().collect::<StringArray>();
         assert_eq!(
-            arrow_array::StringArray::from(string_array)
+            Into::<arrow_array::StringArray>::into(string_array)
                 .into_iter()
                 .flatten()
                 .collect::<Vec<_>>(),
@@ -179,7 +183,7 @@ mod tests {
             .into_iter()
             .collect::<StringArray<Nullable, i64>>();
         assert_eq!(
-            arrow_array::GenericStringArray::<i64>::from(string_array_nullable)
+            Into::<arrow_array::GenericStringArray::<i64>>::into(string_array_nullable)
                 .into_iter()
                 .collect::<Vec<_>>(),
             INPUT_NULLABLE
diff --git a/src/arrow/array/struct.rs b/src/arrow/array/struct.rs
index fb6a5c3..c32b0a4 100644
--- a/src/arrow/array/struct.rs
+++ b/src/arrow/array/struct.rs
@@ -49,50 +49,53 @@ where
     }
 }
 
+#[allow(clippy::from_over_into)]
 impl<T: StructArrayType, Nullable: Nullability, Buffer: BufferType>
-    From<StructArray<T, Nullable, Buffer>> for Arc<dyn arrow_array::Array>
+    Into<Arc<dyn arrow_array::Array>> for StructArray<T, Nullable, Buffer>
 where
-    arrow_array::StructArray: From<StructArray<T, Nullable, Buffer>>,
+    StructArray<T, Nullable, Buffer>: Into<arrow_array::StructArray>,
 {
-    fn from(value: StructArray<T, Nullable, Buffer>) -> Self {
-        Arc::new(arrow_array::StructArray::from(value))
+    fn into(self) -> Arc<dyn arrow_array::Array> {
+        Arc::new(self.into())
     }
 }
 
-impl<T: StructArrayType, Buffer: BufferType> From<StructArray<T, NonNullable, Buffer>>
-    for arrow_array::StructArray
+#[allow(clippy::from_over_into)]
+impl<T: StructArrayType, Buffer: BufferType> Into<arrow_array::StructArray>
+    for StructArray<T, NonNullable, Buffer>
 where
     <T as StructArrayType>::Array<Buffer>:
         StructArrayTypeFields + Into<Vec<Arc<dyn arrow_array::Array>>>,
 {
-    fn from(value: StructArray<T, NonNullable, Buffer>) -> Self {
+    fn into(self) -> arrow_array::StructArray {
         // Safety:
         // - struct arrays are valid by construction
         unsafe {
             arrow_array::StructArray::new_unchecked(
                 <<T as StructArrayType>::Array<Buffer> as StructArrayTypeFields>::fields(),
-                value.0.into(),
+                self.0.into(),
                 None,
             )
         }
     }
 }
 
-impl<T: StructArrayType, Buffer: BufferType> From<StructArray<T, Nullable, Buffer>>
-    for arrow_array::StructArray
+#[allow(clippy::from_over_into)]
+impl<T: StructArrayType, Buffer: BufferType> Into<arrow_array::StructArray>
+    for StructArray<T, Nullable, Buffer>
 where
     <T as StructArrayType>::Array<Buffer>:
         StructArrayTypeFields + Into<Vec<Arc<dyn arrow_array::Array>>>,
     Bitmap<Buffer>: Into<NullBuffer>,
 {
-    fn from(value: StructArray<T, Nullable, Buffer>) -> Self {
+    fn into(self) -> arrow_array::StructArray {
         // Safety:
         // - struct arrays are valid by construction
         unsafe {
             arrow_array::StructArray::new_unchecked(
                 <<T as StructArrayType>::Array<Buffer> as StructArrayTypeFields>::fields(),
-                value.0.data.into(),
-                Some(value.0.validity.into()),
+                self.0.data.into(),
+                Some(self.0.validity.into()),
             )
         }
     }
@@ -154,13 +157,15 @@ where
     }
 }
 
-impl<T: StructArrayType, Nullable: Nullability, Buffer: BufferType>
-    From<StructArray<T, Nullable, Buffer>> for arrow_array::RecordBatch
+#[allow(clippy::from_over_into)]
+impl<T: StructArrayType, Nullable: Nullability, Buffer: BufferType> Into<arrow_array::RecordBatch>
+    for StructArray<T, Nullable, Buffer>
 where
-    arrow_array::StructArray: From<StructArray<T, Nullable, Buffer>>,
+    StructArray<T, Nullable, Buffer>: Into<arrow_array::StructArray>,
 {
-    fn from(value: StructArray<T, Nullable, Buffer>) -> Self {
-        Self::from(arrow_array::StructArray::from(value))
+    fn into(self) -> arrow_array::RecordBatch {
+        let arrow_struct_array: arrow_array::StructArray = self.into();
+        arrow_array::RecordBatch::from(arrow_struct_array)
     }
 }
 
@@ -318,13 +323,13 @@ mod tests {
         let struct_array = [Foo { a: 1 }, Foo { a: 2 }]
             .into_iter()
             .collect::<StructArray<Foo, NonNullable, BufferBuilder>>();
-        let struct_array_arrow = arrow_array::StructArray::from(struct_array);
+        let struct_array_arrow: arrow_array::StructArray = struct_array.into();
         assert_eq!(struct_array_arrow.len(), 2);
 
         let struct_array_nullable = [Some(Foo { a: 1234 }), None]
             .into_iter()
             .collect::<StructArray<Foo, Nullable, BufferBuilder>>();
-        let struct_array_arrow_nullable = arrow_array::StructArray::from(struct_array_nullable);
+        let struct_array_arrow_nullable: arrow_array::StructArray = struct_array_nullable.into();
         assert_eq!(struct_array_arrow_nullable.len(), 2);
         assert!(struct_array_arrow_nullable.is_valid(0));
         assert!(struct_array_arrow_nullable.is_null(1));
@@ -348,7 +353,7 @@ mod tests {
         let struct_array = [Foo { a: 1 }, Foo { a: 2 }]
             .into_iter()
             .collect::<StructArray<Foo, NonNullable, BufferBuilder>>();
-        let struct_array_arrow = arrow_array::StructArray::from(struct_array);
+        let struct_array_arrow: arrow_array::StructArray = struct_array.into();
         assert!(!StructArray::<Foo, Nullable, ScalarBuffer>::from(struct_array_arrow).any_null());
     }
 
@@ -358,7 +363,7 @@ mod tests {
         let struct_array_nullable = [Some(Foo { a: 1234 }), None]
             .into_iter()
             .collect::<StructArray<Foo, Nullable, BufferBuilder>>();
-        let struct_array_arrow_nullable = arrow_array::StructArray::from(struct_array_nullable);
+        let struct_array_arrow_nullable: arrow_array::StructArray = struct_array_nullable.into();
         let _ = StructArray::<Foo, NonNullable, ScalarBuffer>::from(struct_array_arrow_nullable);
     }
 
@@ -367,7 +372,7 @@ mod tests {
         let struct_array = [Foo { a: 1 }, Foo { a: 2 }]
             .into_iter()
             .collect::<StructArray<Foo, NonNullable, BufferBuilder>>();
-        let struct_array_arrow = arrow_array::StructArray::from(struct_array);
+        let struct_array_arrow: arrow_array::StructArray = struct_array.into();
         assert_eq!(
             StructArray::<Foo, NonNullable, ScalarBuffer>::from(struct_array_arrow)
                 .0
@@ -378,7 +383,7 @@ mod tests {
         let struct_array_nullable = [Some(Foo { a: 1234 }), None]
             .into_iter()
             .collect::<StructArray<Foo, Nullable, BufferBuilder>>();
-        let struct_array_arrow_nullable = arrow_array::StructArray::from(struct_array_nullable);
+        let struct_array_arrow_nullable: arrow_array::StructArray = struct_array_nullable.into();
         assert_eq!(
             StructArray::<Foo, Nullable, ScalarBuffer>::from(struct_array_arrow_nullable)
                 .0
@@ -420,7 +425,7 @@ mod tests {
         let struct_array = [Foo(1_i32, 2), Foo(3, 4)]
             .into_iter()
             .collect::<StructArray<Foo<_>, NonNullable>>();
-        let struct_array_arrow = arrow_array::StructArray::from(struct_array);
+        let struct_array_arrow: arrow_array::StructArray = struct_array.into();
         assert_eq!(struct_array_arrow.len(), 2);
 
         let struct_array_roundtrip: StructArray<Foo<i32>> = struct_array_arrow.into();
@@ -490,14 +495,14 @@ mod tests {
         .into_iter()
         .collect::<StructArray<Foo>>();
 
-        let arrow_array = arrow_array::StructArray::from(foo_array);
+        let arrow_array: arrow_array::StructArray = foo_array.into();
         let bar_array = StructArray::<Bar>::from(arrow_array);
         assert_eq!(
             bar_array.clone().into_iter().collect::<Vec<_>>(),
             [Bar { b: false, a: 1 }, Bar { b: true, a: 2 }]
         );
 
-        let bar_arrow_array = arrow_array::StructArray::from(bar_array);
+        let bar_arrow_array: arrow_array::StructArray = bar_array.into();
         let _ = StructArray::<Foo>::from(bar_arrow_array);
     }
 }
diff --git a/src/arrow/array/union.rs b/src/arrow/array/union.rs
index 56358f5..6527ae5 100644
--- a/src/arrow/array/union.rs
+++ b/src/arrow/array/union.rs
@@ -70,20 +70,21 @@ where
     }
 }
 
+#[allow(clippy::from_over_into)]
 impl<
         T: UnionArrayType<VARIANTS>,
         const VARIANTS: usize,
         Buffer: BufferType,
         OffsetItem: Offset,
-    > From<UnionArray<T, VARIANTS, SparseLayout, Buffer, OffsetItem>> for arrow_array::UnionArray
+    > Into<arrow_array::UnionArray> for UnionArray<T, VARIANTS, SparseLayout, Buffer, OffsetItem>
 where
     for<'a> i8: From<&'a T>,
     <T as UnionArrayType<VARIANTS>>::Array<Buffer, OffsetItem, SparseLayout>:
         UnionArrayTypeFields<VARIANTS> + Into<Vec<Arc<dyn arrow_array::Array>>>,
-    arrow_buffer::ScalarBuffer<i8>: From<FixedSizePrimitiveArray<i8, NonNullable, Buffer>>,
+    FixedSizePrimitiveArray<i8, NonNullable, Buffer>: Into<arrow_buffer::ScalarBuffer<i8>>,
     UnionArray<T, VARIANTS, SparseLayout, Buffer, OffsetItem>: crate::arrow::Array,
 {
-    fn from(value: UnionArray<T, VARIANTS, SparseLayout, Buffer, OffsetItem>) -> Self {
+    fn into(self) -> arrow_array::UnionArray {
         let union_fields = match < UnionArray<T, VARIANTS, SparseLayout, Buffer, OffsetItem> as crate::arrow::Array>::as_field("").data_type() {
             &DataType::Union(ref fields, _mode) => fields.to_owned(),
             _ => unreachable!(),
@@ -93,48 +94,50 @@ where
         unsafe {
             arrow_array::UnionArray::new_unchecked(
                 union_fields,
-                arrow_buffer::ScalarBuffer::from(value.0.types),
+                Into::<arrow_buffer::ScalarBuffer<i8>>::into(self.0.types),
                 None,
-                value.0.variants.into(),
+                self.0.variants.into(),
             )
         }
     }
 }
 
+#[allow(clippy::from_over_into)]
 impl<
         T: UnionArrayType<VARIANTS>,
         const VARIANTS: usize,
         Buffer: BufferType,
         OffsetItem: Offset,
-    > From<UnionArray<T, VARIANTS, SparseLayout, Buffer, OffsetItem>>
-    for Arc<dyn arrow_array::Array>
+    > Into<Arc<dyn arrow_array::Array>>
+    for UnionArray<T, VARIANTS, SparseLayout, Buffer, OffsetItem>
 where
     for<'a> i8: From<&'a T>,
     <T as UnionArrayType<VARIANTS>>::Array<Buffer, OffsetItem, SparseLayout>:
         UnionArrayTypeFields<VARIANTS> + Into<Vec<Arc<dyn arrow_array::Array>>>,
-    arrow_buffer::ScalarBuffer<i8>: From<FixedSizePrimitiveArray<i8, NonNullable, Buffer>>,
+    FixedSizePrimitiveArray<i8, NonNullable, Buffer>: Into<arrow_buffer::ScalarBuffer<i8>>,
     UnionArray<T, VARIANTS, SparseLayout, Buffer, OffsetItem>: crate::arrow::Array,
 {
-    fn from(value: UnionArray<T, VARIANTS, SparseLayout, Buffer, OffsetItem>) -> Self {
-        Arc::new(arrow_array::UnionArray::from(value))
+    fn into(self) -> Arc<dyn arrow_array::Array> {
+        Arc::new(Into::<arrow_array::UnionArray>::into(self))
     }
 }
 
+#[allow(clippy::from_over_into)]
 impl<
         T: UnionArrayType<VARIANTS>,
         const VARIANTS: usize,
         Buffer: BufferType,
         OffsetItem: Offset,
-    > From<UnionArray<T, VARIANTS, DenseLayout, Buffer, OffsetItem>> for arrow_array::UnionArray
+    > Into<arrow_array::UnionArray> for UnionArray<T, VARIANTS, DenseLayout, Buffer, OffsetItem>
 where
     for<'a> i8: From<&'a T>,
     <T as UnionArrayType<VARIANTS>>::Array<Buffer, OffsetItem, DenseLayout>:
         UnionArrayTypeFields<VARIANTS> + Into<Vec<Arc<dyn arrow_array::Array>>>,
-    arrow_buffer::ScalarBuffer<i8>: From<FixedSizePrimitiveArray<i8, NonNullable, Buffer>>,
-    arrow_buffer::ScalarBuffer<i32>: From<FixedSizePrimitiveArray<i32, NonNullable, Buffer>>,
+    FixedSizePrimitiveArray<i8, NonNullable, Buffer>: Into<arrow_buffer::ScalarBuffer<i8>>,
+    FixedSizePrimitiveArray<i32, NonNullable, Buffer>: Into<arrow_buffer::ScalarBuffer<i32>>,
     UnionArray<T, VARIANTS, SparseLayout, Buffer, OffsetItem>: crate::arrow::Array,
 {
-    fn from(value: UnionArray<T, VARIANTS, DenseLayout, Buffer, OffsetItem>) -> Self {
+    fn into(self) -> arrow_array::UnionArray {
         let union_fields = match < UnionArray<T, VARIANTS, DenseLayout, Buffer, OffsetItem> as crate::arrow::Array>::as_field("").data_type() {
             &DataType::Union(ref fields, _mode) => fields.to_owned(),
             _ => unreachable!(),
@@ -144,30 +147,33 @@ where
         unsafe {
             arrow_array::UnionArray::new_unchecked(
                 union_fields,
-                arrow_buffer::ScalarBuffer::from(value.0.types),
-                Some(arrow_buffer::ScalarBuffer::<i32>::from(value.0.offsets)),
-                value.0.variants.into(),
+                Into::<arrow_buffer::ScalarBuffer<i8>>::into(self.0.types),
+                Some(Into::<arrow_buffer::ScalarBuffer<i32>>::into(
+                    self.0.offsets,
+                )),
+                self.0.variants.into(),
             )
         }
     }
 }
 
+#[allow(clippy::from_over_into)]
 impl<
         T: UnionArrayType<VARIANTS>,
         const VARIANTS: usize,
         Buffer: BufferType,
         OffsetItem: Offset,
-    > From<UnionArray<T, VARIANTS, DenseLayout, Buffer, OffsetItem>> for Arc<dyn arrow_array::Array>
+    > Into<Arc<dyn arrow_array::Array>> for UnionArray<T, VARIANTS, DenseLayout, Buffer, OffsetItem>
 where
     for<'a> i8: From<&'a T>,
     <T as UnionArrayType<VARIANTS>>::Array<Buffer, OffsetItem, DenseLayout>:
         UnionArrayTypeFields<VARIANTS> + Into<Vec<Arc<dyn arrow_array::Array>>>,
-    arrow_buffer::ScalarBuffer<i8>: From<FixedSizePrimitiveArray<i8, NonNullable, Buffer>>,
-    arrow_buffer::ScalarBuffer<i32>: From<FixedSizePrimitiveArray<i32, NonNullable, Buffer>>,
+    FixedSizePrimitiveArray<i8, NonNullable, Buffer>: Into<arrow_buffer::ScalarBuffer<i8>>,
+    FixedSizePrimitiveArray<i32, NonNullable, Buffer>: Into<arrow_buffer::ScalarBuffer<i32>>,
     UnionArray<T, VARIANTS, SparseLayout, Buffer, OffsetItem>: crate::arrow::Array,
 {
-    fn from(value: UnionArray<T, VARIANTS, DenseLayout, Buffer, OffsetItem>) -> Self {
-        Arc::new(arrow_array::UnionArray::from(value))
+    fn into(self) -> Arc<dyn arrow_array::Array> {
+        Arc::new(Into::<arrow_array::UnionArray>::into(self))
     }
 }
 
@@ -282,7 +288,7 @@ mod tests {
     fn via_dyn_array() {
         let input = [Wrap(FooBar::Foo), Wrap(FooBar::Bar(123))];
         let struct_array = input.clone().into_iter().collect::<StructArray<Wrap>>();
-        let record_batch = RecordBatch::from(struct_array);
+        let record_batch: RecordBatch = struct_array.into();
         let read = StructArray::<Wrap>::from(record_batch);
         assert_eq!(read.into_iter().collect::<Vec<_>>(), input);
     }
@@ -300,14 +306,14 @@ mod tests {
             .into_iter()
             .collect::<UnionArray<FooBar, 3, SparseLayout>>();
         assert_eq!(sparse_union_array.len(), 4);
-        let union_array_arrow = arrow_array::UnionArray::from(sparse_union_array);
+        let union_array_arrow: arrow_array::UnionArray = sparse_union_array.into();
         assert_eq!(arrow_array::Array::len(&union_array_arrow), 4);
 
         let dense_union_array = input
             .into_iter()
             .collect::<UnionArray<FooBar, 3, DenseLayout>>();
         assert_eq!(dense_union_array.len(), 4);
-        let dense_union_array_arrow = arrow_array::UnionArray::from(dense_union_array);
+        let dense_union_array_arrow: arrow_array::UnionArray = dense_union_array.into();
         assert_eq!(arrow_array::Array::len(&dense_union_array_arrow), 4);
     }
 
@@ -323,14 +329,14 @@ mod tests {
             .clone()
             .into_iter()
             .collect::<UnionArray<FooBar, 3, SparseLayout>>();
-        let union_array_arrow = arrow_array::UnionArray::from(sparse_union_array);
+        let union_array_arrow: arrow_array::UnionArray = sparse_union_array.into();
         let narrow_union_array: UnionArray<FooBar, 3, SparseLayout> = union_array_arrow.into();
         assert_eq!(narrow_union_array.len(), 4);
 
         let dense_union_array = input
             .into_iter()
             .collect::<UnionArray<FooBar, 3, DenseLayout>>();
-        let dense_union_array_arrow = arrow_array::UnionArray::from(dense_union_array);
+        let dense_union_array_arrow: arrow_array::UnionArray = dense_union_array.into();
         let narrow_dense_union_array: UnionArray<FooBar, 3, DenseLayout> =
             dense_union_array_arrow.into();
         assert_eq!(narrow_dense_union_array.len(), 4);
@@ -349,7 +355,7 @@ mod tests {
             .clone()
             .into_iter()
             .collect::<UnionArray<FooBar, 3, SparseLayout>>();
-        let union_array_arrow = arrow_array::UnionArray::from(union_array);
+        let union_array_arrow: arrow_array::UnionArray = union_array.into();
         let _: UnionArray<FooBar, 3, DenseLayout> = union_array_arrow.into();
     }
 
@@ -366,7 +372,7 @@ mod tests {
             .clone()
             .into_iter()
             .collect::<UnionArray<FooBar, 3, DenseLayout>>();
-        let union_array_arrow = arrow_array::UnionArray::from(union_array);
+        let union_array_arrow: arrow_array::UnionArray = union_array.into();
         let _array: UnionArray<FooBar, 3, SparseLayout> = union_array_arrow.into();
     }
 
@@ -388,7 +394,7 @@ mod tests {
             .clone()
             .into_iter()
             .collect::<UnionArray<FooBar, 3, DenseLayout>>();
-        let union_array_arrow = arrow_array::UnionArray::from(union_array);
+        let union_array_arrow: arrow_array::UnionArray = union_array.into();
         let _array: UnionArray<Bar, 2, DenseLayout> = union_array_arrow.into();
     }
 
@@ -412,7 +418,7 @@ mod tests {
         let union_array = input
             .into_iter()
             .collect::<UnionArray<One, 1, SparseLayout>>();
-        let union_array_arrow = arrow_array::UnionArray::from(union_array);
+        let union_array_arrow: arrow_array::UnionArray = union_array.into();
         let _array: UnionArray<Bar, 6, SparseLayout> = union_array_arrow.into();
     }
 }
diff --git a/src/arrow/array/variable_size_binary.rs b/src/arrow/array/variable_size_binary.rs
index 4452ade..2002d84 100644
--- a/src/arrow/array/variable_size_binary.rs
+++ b/src/arrow/array/variable_size_binary.rs
@@ -46,64 +46,68 @@ where
     }
 }
 
-impl<OffsetItem: Offset + OffsetSizeTrait, Buffer: BufferType>
-    From<VariableSizeBinaryArray<NonNullable, OffsetItem, Buffer>> for Arc<dyn arrow_array::Array>
+#[allow(clippy::from_over_into)]
+impl<OffsetItem: Offset + OffsetSizeTrait, Buffer: BufferType> Into<Arc<dyn arrow_array::Array>>
+    for VariableSizeBinaryArray<NonNullable, OffsetItem, Buffer>
 where
     <Buffer as BufferType>::Buffer<OffsetItem>: Into<ScalarBuffer<OffsetItem>>,
     FixedSizePrimitiveArray<u8, NonNullable, Buffer>: Into<arrow_buffer::ScalarBuffer<u8>>,
 {
-    fn from(value: VariableSizeBinaryArray<NonNullable, OffsetItem, Buffer>) -> Self {
-        let array: arrow_array::GenericBinaryArray<OffsetItem> = value.into();
+    fn into(self) -> Arc<dyn arrow_array::Array> {
+        let array: arrow_array::GenericBinaryArray<OffsetItem> = self.into();
         Arc::new(array)
     }
 }
 
-impl<OffsetItem: Offset + OffsetSizeTrait, Buffer: BufferType>
-    From<VariableSizeBinaryArray<Nullable, OffsetItem, Buffer>> for Arc<dyn arrow_array::Array>
+#[allow(clippy::from_over_into)]
+impl<OffsetItem: Offset + OffsetSizeTrait, Buffer: BufferType> Into<Arc<dyn arrow_array::Array>>
+    for VariableSizeBinaryArray<Nullable, OffsetItem, Buffer>
 where
     <Buffer as BufferType>::Buffer<OffsetItem>: Into<ScalarBuffer<OffsetItem>>,
     FixedSizePrimitiveArray<u8, NonNullable, Buffer>: Into<arrow_buffer::ScalarBuffer<u8>>,
     Bitmap<Buffer>: Into<NullBuffer>,
 {
-    fn from(value: VariableSizeBinaryArray<Nullable, OffsetItem, Buffer>) -> Self {
-        let array: arrow_array::GenericBinaryArray<OffsetItem> = value.into();
+    fn into(self) -> Arc<dyn arrow_array::Array> {
+        let array: arrow_array::GenericBinaryArray<OffsetItem> = self.into();
         Arc::new(array)
     }
 }
 
+#[allow(clippy::from_over_into)]
 impl<OffsetItem: Offset + OffsetSizeTrait, Buffer: BufferType>
-    From<VariableSizeBinaryArray<NonNullable, OffsetItem, Buffer>>
-    for arrow_array::GenericBinaryArray<OffsetItem>
+    Into<arrow_array::GenericBinaryArray<OffsetItem>>
+    for VariableSizeBinaryArray<NonNullable, OffsetItem, Buffer>
 where
     <Buffer as BufferType>::Buffer<OffsetItem>: Into<ScalarBuffer<OffsetItem>>,
     FixedSizePrimitiveArray<u8, NonNullable, Buffer>: Into<arrow_buffer::ScalarBuffer<u8>>,
 {
-    fn from(value: VariableSizeBinaryArray<NonNullable, OffsetItem, Buffer>) -> Self {
+    fn into(self) -> arrow_array::GenericBinaryArray<OffsetItem> {
         arrow_array::GenericBinaryArray::new(
             // Safety:
             // - The narrow offset buffer contains valid offset data
-            unsafe { OffsetBuffer::new_unchecked(value.0.offsets.into()) },
-            value.0.data.into().into_inner(),
+            unsafe { OffsetBuffer::new_unchecked(self.0.offsets.into()) },
+            self.0.data.into().into_inner(),
             None,
         )
     }
 }
 
+#[allow(clippy::from_over_into)]
 impl<OffsetItem: Offset + OffsetSizeTrait, Buffer: BufferType>
-    From<VariableSizeBinaryArray<Nullable, OffsetItem, Buffer>>
-    for arrow_array::GenericBinaryArray<OffsetItem>
+    Into<arrow_array::GenericBinaryArray<OffsetItem>>
+    for VariableSizeBinaryArray<Nullable, OffsetItem, Buffer>
 where
     <Buffer as BufferType>::Buffer<OffsetItem>: Into<ScalarBuffer<OffsetItem>>,
     FixedSizePrimitiveArray<u8, NonNullable, Buffer>: Into<arrow_buffer::ScalarBuffer<u8>>,
     Bitmap<Buffer>: Into<NullBuffer>,
 {
-    fn from(value: VariableSizeBinaryArray<Nullable, OffsetItem, Buffer>) -> Self {
+    fn into(self) -> arrow_array::GenericBinaryArray<OffsetItem> {
         arrow_array::GenericBinaryArray::new(
             // Safety:
             // - The narrow offset buffer contains valid offset data
-            unsafe { OffsetBuffer::new_unchecked(value.0.offsets.data.into()) },
-            value.0.data.into().into_inner(),
-            Some(value.0.offsets.validity.into()),
+            unsafe { OffsetBuffer::new_unchecked(self.0.offsets.data.into()) },
+            self.0.data.into().into_inner(),
+            Some(self.0.offsets.validity.into()),
         )
     }
 }
@@ -173,7 +177,7 @@ mod tests {
     fn from() {
         let vsb_array = input().into_iter().collect::<VariableSizeBinaryArray>();
         assert_eq!(
-            arrow_array::BinaryArray::from(vsb_array)
+            Into::<arrow_array::BinaryArray>::into(vsb_array)
                 .into_iter()
                 .flatten()
                 .collect::<Vec<_>>(),
@@ -184,7 +188,7 @@ mod tests {
             .into_iter()
             .collect::<VariableSizeBinaryArray<Nullable, i64>>();
         assert_eq!(
-            arrow_array::GenericBinaryArray::<i64>::from(vsb_array_nullable)
+            Into::<arrow_array::GenericBinaryArray::<i64>>::into(vsb_array_nullable)
                 .into_iter()
                 .map(|o| o.map(<[u8]>::to_vec))
                 .collect::<Vec<_>>(),
diff --git a/src/arrow/array/variable_size_list.rs b/src/arrow/array/variable_size_list.rs
index 359f38f..11c11c6 100644
--- a/src/arrow/array/variable_size_list.rs
+++ b/src/arrow/array/variable_size_list.rs
@@ -50,66 +50,70 @@ where
     }
 }
 
+#[allow(clippy::from_over_into)]
 impl<T: Array + crate::arrow::Array, OffsetItem: Offset + OffsetSizeTrait, Buffer: BufferType>
-    From<VariableSizeListArray<T, NonNullable, OffsetItem, Buffer>> for Arc<dyn arrow_array::Array>
+    Into<Arc<dyn arrow_array::Array>> for VariableSizeListArray<T, NonNullable, OffsetItem, Buffer>
 where
     <Buffer as BufferType>::Buffer<OffsetItem>: Into<ScalarBuffer<OffsetItem>>,
-    <T as crate::arrow::Array>::Array: From<T> + 'static,
+    T: Into<<T as crate::arrow::Array>::Array> + 'static,
 {
-    fn from(value: VariableSizeListArray<T, NonNullable, OffsetItem, Buffer>) -> Self {
-        let array: arrow_array::GenericListArray<OffsetItem> = value.into();
+    fn into(self) -> Arc<dyn arrow_array::Array> {
+        let array: arrow_array::GenericListArray<OffsetItem> = self.into();
         Arc::new(array)
     }
 }
 
+#[allow(clippy::from_over_into)]
 impl<T: Array + crate::arrow::Array, OffsetItem: Offset + OffsetSizeTrait, Buffer: BufferType>
-    From<VariableSizeListArray<T, Nullable, OffsetItem, Buffer>> for Arc<dyn arrow_array::Array>
+    Into<Arc<dyn arrow_array::Array>> for VariableSizeListArray<T, Nullable, OffsetItem, Buffer>
 where
     <Buffer as BufferType>::Buffer<OffsetItem>: Into<ScalarBuffer<OffsetItem>>,
     Bitmap<Buffer>: Into<NullBuffer>,
-    <T as crate::arrow::Array>::Array: From<T> + 'static,
+    T: Into<<T as crate::arrow::Array>::Array> + 'static,
 {
-    fn from(value: VariableSizeListArray<T, Nullable, OffsetItem, Buffer>) -> Self {
-        let array: arrow_array::GenericListArray<OffsetItem> = value.into();
+    fn into(self) -> Arc<dyn arrow_array::Array> {
+        let array: arrow_array::GenericListArray<OffsetItem> = self.into();
         Arc::new(array)
     }
 }
 
+#[allow(clippy::from_over_into)]
 impl<T: Array + crate::arrow::Array, OffsetItem: Offset + OffsetSizeTrait, Buffer: BufferType>
-    From<VariableSizeListArray<T, NonNullable, OffsetItem, Buffer>>
-    for arrow_array::GenericListArray<OffsetItem>
+    Into<arrow_array::GenericListArray<OffsetItem>>
+    for VariableSizeListArray<T, NonNullable, OffsetItem, Buffer>
 where
     <Buffer as BufferType>::Buffer<OffsetItem>: Into<ScalarBuffer<OffsetItem>>,
-    <T as crate::arrow::Array>::Array: From<T> + 'static,
+    T: Into<<T as crate::arrow::Array>::Array> + 'static,
 {
-    fn from(value: VariableSizeListArray<T, NonNullable, OffsetItem, Buffer>) -> Self {
+    fn into(self) -> arrow_array::GenericListArray<OffsetItem> {
         arrow_array::GenericListArray::new(
             Arc::new(T::as_field("item")),
             // Safety:
             // - The narrow offfset buffer contains valid offset data
-            unsafe { OffsetBuffer::new_unchecked(value.0.offsets.into()) },
-            Arc::<<T as crate::arrow::Array>::Array>::new(value.0.data.into()),
+            unsafe { OffsetBuffer::new_unchecked(self.0.offsets.into()) },
+            Arc::<<T as crate::arrow::Array>::Array>::new(self.0.data.into()),
             None,
         )
     }
 }
 
+#[allow(clippy::from_over_into)]
 impl<T: Array + crate::arrow::Array, OffsetItem: Offset + OffsetSizeTrait, Buffer: BufferType>
-    From<VariableSizeListArray<T, Nullable, OffsetItem, Buffer>>
-    for arrow_array::GenericListArray<OffsetItem>
+    Into<arrow_array::GenericListArray<OffsetItem>>
+    for VariableSizeListArray<T, Nullable, OffsetItem, Buffer>
 where
     <Buffer as BufferType>::Buffer<OffsetItem>: Into<ScalarBuffer<OffsetItem>>,
     Bitmap<Buffer>: Into<NullBuffer>,
-    <T as crate::arrow::Array>::Array: From<T> + 'static,
+    T: Into<<T as crate::arrow::Array>::Array> + 'static,
 {
-    fn from(value: VariableSizeListArray<T, Nullable, OffsetItem, Buffer>) -> Self {
+    fn into(self) -> arrow_array::GenericListArray<OffsetItem> {
         arrow_array::GenericListArray::new(
             Arc::new(T::as_field("item")),
             // Safety:
             // - The narrow offfset buffer contains valid offset data
-            unsafe { OffsetBuffer::new_unchecked(value.0.offsets.data.into()) },
-            Arc::<<T as crate::arrow::Array>::Array>::new(value.0.data.into()),
-            Some(value.0.offsets.validity.into()),
+            unsafe { OffsetBuffer::new_unchecked(self.0.offsets.data.into()) },
+            Arc::<<T as crate::arrow::Array>::Array>::new(self.0.data.into()),
+            Some(self.0.offsets.validity.into()),
         )
     }
 }
@@ -187,13 +191,13 @@ mod tests {
         let variable_size_list_array = INPUT
             .into_iter()
             .collect::<VariableSizeListArray<Uint16Array>>();
-        let list_array = arrow_array::ListArray::from(variable_size_list_array);
+        let list_array: arrow_array::ListArray = variable_size_list_array.into();
         assert_eq!(list_array.len(), INPUT.len());
 
         let variable_size_list_array_nullable = INPUT_NULLABLE
             .into_iter()
             .collect::<VariableSizeListArray<StringArray, Nullable>>();
-        let list_array_nullable = arrow_array::ListArray::from(variable_size_list_array_nullable);
+        let list_array_nullable: arrow_array::ListArray = variable_size_list_array_nullable.into();
         assert_eq!(list_array_nullable.len(), INPUT_NULLABLE.len());
     }
 
diff --git a/src/arrow/bitmap.rs b/src/arrow/bitmap.rs
index 2a23ead..2ede0c6 100644
--- a/src/arrow/bitmap.rs
+++ b/src/arrow/bitmap.rs
@@ -2,21 +2,23 @@
 
 use crate::{bitmap::Bitmap, buffer::BufferType, Length};
 
-impl<Buffer: BufferType> From<Bitmap<Buffer>> for arrow_buffer::BooleanBuffer
+#[allow(clippy::from_over_into)]
+impl<Buffer: BufferType> Into<arrow_buffer::BooleanBuffer> for Bitmap<Buffer>
 where
     <Buffer as BufferType>::Buffer<u8>: Into<arrow_buffer::Buffer>,
 {
-    fn from(value: Bitmap<Buffer>) -> Self {
-        Self::new(value.buffer.into(), value.offset, value.bits)
+    fn into(self) -> arrow_buffer::BooleanBuffer {
+        arrow_buffer::BooleanBuffer::new(self.buffer.into(), self.offset, self.bits)
     }
 }
 
-impl<Buffer: BufferType> From<Bitmap<Buffer>> for arrow_buffer::NullBuffer
+#[allow(clippy::from_over_into)]
+impl<Buffer: BufferType> Into<arrow_buffer::NullBuffer> for Bitmap<Buffer>
 where
-    arrow_buffer::BooleanBuffer: From<Bitmap<Buffer>>,
+    Bitmap<Buffer>: Into<arrow_buffer::BooleanBuffer>,
 {
-    fn from(value: Bitmap<Buffer>) -> Self {
-        Self::new(value.into())
+    fn into(self) -> arrow_buffer::NullBuffer {
+        arrow_buffer::NullBuffer::new(self.into())
     }
 }