diff --git a/src/compute/arithmetics/basic/div.rs b/src/compute/arithmetics/basic/div.rs
index 77d65e8f88f..b7f22a0d771 100644
--- a/src/compute/arithmetics/basic/div.rs
+++ b/src/compute/arithmetics/basic/div.rs
@@ -117,60 +117,49 @@ where
             let rhs = rhs.to_u64().unwrap();
 
             let reduced_div = StrengthReducedU64::new(rhs);
-            // Safety: we just proved that `lhs` is `PrimitiveArray<u64>` which means that
-            // T = u64
-            unsafe {
-                std::mem::transmute::<PrimitiveArray<u64>, PrimitiveArray<T>>(unary(
-                    lhs,
-                    |a| a / reduced_div,
-                    lhs.data_type().clone(),
-                ))
-            }
+            let r = unary(lhs, |a| a / reduced_div, lhs.data_type().clone());
+            (&r as &dyn Array)
+                .as_any()
+                .downcast_ref::<PrimitiveArray<T>>()
+                .unwrap()
+                .clone()
         }
         PrimitiveType::UInt32 => {
             let lhs = lhs.as_any().downcast_ref::<PrimitiveArray<u32>>().unwrap();
             let rhs = rhs.to_u32().unwrap();
 
             let reduced_div = StrengthReducedU32::new(rhs);
-            // Safety: we just proved that `lhs` is `PrimitiveArray<u32>` which means that
-            // T = u32
-            unsafe {
-                std::mem::transmute::<PrimitiveArray<u32>, PrimitiveArray<T>>(unary(
-                    lhs,
-                    |a| a / reduced_div,
-                    lhs.data_type().clone(),
-                ))
-            }
+            let r = unary(lhs, |a| a / reduced_div, lhs.data_type().clone());
+            (&r as &dyn Array)
+                .as_any()
+                .downcast_ref::<PrimitiveArray<T>>()
+                .unwrap()
+                .clone()
         }
         PrimitiveType::UInt16 => {
             let lhs = lhs.as_any().downcast_ref::<PrimitiveArray<u16>>().unwrap();
             let rhs = rhs.to_u16().unwrap();
 
             let reduced_div = StrengthReducedU16::new(rhs);
-            // Safety: we just proved that `lhs` is `PrimitiveArray<u16>` which means that
-            // T = u16
-            unsafe {
-                std::mem::transmute::<PrimitiveArray<u16>, PrimitiveArray<T>>(unary(
-                    lhs,
-                    |a| a / reduced_div,
-                    lhs.data_type().clone(),
-                ))
-            }
+
+            let r = unary(lhs, |a| a / reduced_div, lhs.data_type().clone());
+            (&r as &dyn Array)
+                .as_any()
+                .downcast_ref::<PrimitiveArray<T>>()
+                .unwrap()
+                .clone()
         }
         PrimitiveType::UInt8 => {
             let lhs = lhs.as_any().downcast_ref::<PrimitiveArray<u8>>().unwrap();
             let rhs = rhs.to_u8().unwrap();
 
             let reduced_div = StrengthReducedU8::new(rhs);
-            // Safety: we just proved that `lhs` is `PrimitiveArray<u8>` which means that
-            // T = u8
-            unsafe {
-                std::mem::transmute::<PrimitiveArray<u8>, PrimitiveArray<T>>(unary(
-                    lhs,
-                    |a| a / reduced_div,
-                    lhs.data_type().clone(),
-                ))
-            }
+            let r = unary(lhs, |a| a / reduced_div, lhs.data_type().clone());
+            (&r as &dyn Array)
+                .as_any()
+                .downcast_ref::<PrimitiveArray<T>>()
+                .unwrap()
+                .clone()
         }
         _ => unary(lhs, |a| a / rhs, lhs.data_type().clone()),
     }
diff --git a/src/compute/arithmetics/basic/rem.rs b/src/compute/arithmetics/basic/rem.rs
index 0d37169ef77..79a6055b8fd 100644
--- a/src/compute/arithmetics/basic/rem.rs
+++ b/src/compute/arithmetics/basic/rem.rs
@@ -104,60 +104,56 @@ where
             let rhs = rhs.to_u64().unwrap();
 
             let reduced_rem = StrengthReducedU64::new(rhs);
-            // Safety: we just proved that `lhs` is `PrimitiveArray<u64>` which means that
-            // T = u64
-            unsafe {
-                std::mem::transmute::<PrimitiveArray<u64>, PrimitiveArray<T>>(unary(
-                    lhs,
-                    |a| a % reduced_rem,
-                    lhs.data_type().clone(),
-                ))
-            }
+
+            // small hack to avoid a transmute of `PrimitiveArray<u64>` to `PrimitiveArray<T>`
+            let r = unary(lhs, |a| a % reduced_rem, lhs.data_type().clone());
+            (&r as &dyn Array)
+                .as_any()
+                .downcast_ref::<PrimitiveArray<T>>()
+                .unwrap()
+                .clone()
         }
         PrimitiveType::UInt32 => {
             let lhs = lhs.as_any().downcast_ref::<PrimitiveArray<u32>>().unwrap();
             let rhs = rhs.to_u32().unwrap();
 
             let reduced_rem = StrengthReducedU32::new(rhs);
-            // Safety: we just proved that `lhs` is `PrimitiveArray<u32>` which means that
-            // T = u32
-            unsafe {
-                std::mem::transmute::<PrimitiveArray<u32>, PrimitiveArray<T>>(unary(
-                    lhs,
-                    |a| a % reduced_rem,
-                    lhs.data_type().clone(),
-                ))
-            }
+
+            let r = unary(lhs, |a| a % reduced_rem, lhs.data_type().clone());
+            // small hack to avoid an unsafe transmute of `PrimitiveArray<u64>` to `PrimitiveArray<T>`
+            (&r as &dyn Array)
+                .as_any()
+                .downcast_ref::<PrimitiveArray<T>>()
+                .unwrap()
+                .clone()
         }
         PrimitiveType::UInt16 => {
             let lhs = lhs.as_any().downcast_ref::<PrimitiveArray<u16>>().unwrap();
             let rhs = rhs.to_u16().unwrap();
 
             let reduced_rem = StrengthReducedU16::new(rhs);
-            // Safety: we just proved that `lhs` is `PrimitiveArray<u16>` which means that
-            // T = u16
-            unsafe {
-                std::mem::transmute::<PrimitiveArray<u16>, PrimitiveArray<T>>(unary(
-                    lhs,
-                    |a| a % reduced_rem,
-                    lhs.data_type().clone(),
-                ))
-            }
+
+            let r = unary(lhs, |a| a % reduced_rem, lhs.data_type().clone());
+            // small hack to avoid an unsafe transmute of `PrimitiveArray<u16>` to `PrimitiveArray<T>`
+            (&r as &dyn Array)
+                .as_any()
+                .downcast_ref::<PrimitiveArray<T>>()
+                .unwrap()
+                .clone()
         }
         PrimitiveType::UInt8 => {
             let lhs = lhs.as_any().downcast_ref::<PrimitiveArray<u8>>().unwrap();
             let rhs = rhs.to_u8().unwrap();
 
             let reduced_rem = StrengthReducedU8::new(rhs);
-            // Safety: we just proved that `lhs` is `PrimitiveArray<u8>` which means that
-            // T = u8
-            unsafe {
-                std::mem::transmute::<PrimitiveArray<u8>, PrimitiveArray<T>>(unary(
-                    lhs,
-                    |a| a % reduced_rem,
-                    lhs.data_type().clone(),
-                ))
-            }
+
+            let r = unary(lhs, |a| a % reduced_rem, lhs.data_type().clone());
+            // small hack to avoid an unsafe transmute of `PrimitiveArray<u8>` to `PrimitiveArray<T>`
+            (&r as &dyn Array)
+                .as_any()
+                .downcast_ref::<PrimitiveArray<T>>()
+                .unwrap()
+                .clone()
         }
         _ => unary(lhs, |a| a % rhs, lhs.data_type().clone()),
     }
diff --git a/src/compute/arithmetics/mod.rs b/src/compute/arithmetics/mod.rs
index 34ab0bf1722..5766385d8a4 100644
--- a/src/compute/arithmetics/mod.rs
+++ b/src/compute/arithmetics/mod.rs
@@ -11,7 +11,7 @@
 //! * overflowing: returns an extra [`Bitmap`] denoting whether the operation overflowed.
 //! * adaptive: for [`Decimal`](crate::datatypes::DataType::Decimal) only,
 //!   adjusts the precision and scale to make the resulting value fit.
-
+#[forbid(unsafe_code)]
 pub mod basic;
 pub mod decimal;
 pub mod time;