diff --git a/src/compute/aggregate/min_max.rs b/src/compute/aggregate/min_max.rs
index a8eac2dc8e5..4e6adc7390f 100644
--- a/src/compute/aggregate/min_max.rs
+++ b/src/compute/aggregate/min_max.rs
@@ -9,14 +9,24 @@ use crate::{
     bitmap::Bitmap,
 };
 
+/// Trait describing a type describing multiple lanes with an order relationship
+/// consistent with the same order of `T`.
 pub trait SimdOrd<T> {
+    /// The minimum value
     const MIN: T;
+    /// The maximum value
     const MAX: T;
+    /// reduce itself to the minimum
     fn max_element(self) -> T;
+    /// reduce itself to the maximum
     fn min_element(self) -> T;
+    /// lane-wise maximum between two instances
     fn max(self, x: Self) -> Self;
+    /// lane-wise minimum between two instances
     fn min(self, x: Self) -> Self;
+    /// returns a new instance with all lanes equal to `MIN`
     fn new_min() -> Self;
+    /// returns a new instance with all lanes equal to `MAX`
     fn new_max() -> Self;
 }
 
@@ -350,6 +360,9 @@ macro_rules! dyn_generic {
     }};
 }
 
+/// Returns the maximum of [`Array`]. The scalar is null when all elements are null.
+/// # Error
+/// Errors iff the type does not support this operation.
 pub fn max(array: &dyn Array) -> Result<Box<dyn Scalar>> {
     Ok(match array.data_type() {
         DataType::Boolean => dyn_generic!(BooleanArray, BooleanScalar, array, max_boolean),
@@ -388,6 +401,9 @@ pub fn max(array: &dyn Array) -> Result<Box<dyn Scalar>> {
     })
 }
 
+/// Returns the minimum of [`Array`]. The scalar is null when all elements are null.
+/// # Error
+/// Errors iff the type does not support this operation.
 pub fn min(array: &dyn Array) -> Result<Box<dyn Scalar>> {
     Ok(match array.data_type() {
         DataType::Boolean => dyn_generic!(BooleanArray, BooleanScalar, array, min_boolean),
diff --git a/src/compute/arithmetics/basic/add.rs b/src/compute/arithmetics/basic/add.rs
index d71abfaec39..7bddf42ef8e 100644
--- a/src/compute/arithmetics/basic/add.rs
+++ b/src/compute/arithmetics/basic/add.rs
@@ -160,9 +160,7 @@ impl<T> ArrayAdd<PrimitiveArray<T>> for PrimitiveArray<T>
 where
     T: NativeArithmetics + Add<Output = T>,
 {
-    type Output = Self;
-
-    fn add(&self, rhs: &PrimitiveArray<T>) -> Result<Self::Output> {
+    fn add(&self, rhs: &PrimitiveArray<T>) -> Result<Self> {
         add(self, rhs)
     }
 }
@@ -171,9 +169,7 @@ impl<T> ArrayWrappingAdd<PrimitiveArray<T>> for PrimitiveArray<T>
 where
     T: NativeArithmetics + WrappingAdd<Output = T>,
 {
-    type Output = Self;
-
-    fn wrapping_add(&self, rhs: &PrimitiveArray<T>) -> Result<Self::Output> {
+    fn wrapping_add(&self, rhs: &PrimitiveArray<T>) -> Result<Self> {
         wrapping_add(self, rhs)
     }
 }
@@ -183,9 +179,7 @@ impl<T> ArrayCheckedAdd<PrimitiveArray<T>> for PrimitiveArray<T>
 where
     T: NativeArithmetics + CheckedAdd<Output = T>,
 {
-    type Output = Self;
-
-    fn checked_add(&self, rhs: &PrimitiveArray<T>) -> Result<Self::Output> {
+    fn checked_add(&self, rhs: &PrimitiveArray<T>) -> Result<Self> {
         checked_add(self, rhs)
     }
 }
@@ -195,9 +189,7 @@ impl<T> ArraySaturatingAdd<PrimitiveArray<T>> for PrimitiveArray<T>
 where
     T: NativeArithmetics + SaturatingAdd<Output = T>,
 {
-    type Output = Self;
-
-    fn saturating_add(&self, rhs: &PrimitiveArray<T>) -> Result<Self::Output> {
+    fn saturating_add(&self, rhs: &PrimitiveArray<T>) -> Result<Self> {
         saturating_add(self, rhs)
     }
 }
@@ -207,9 +199,7 @@ impl<T> ArrayOverflowingAdd<PrimitiveArray<T>> for PrimitiveArray<T>
 where
     T: NativeArithmetics + OverflowingAdd<Output = T>,
 {
-    type Output = Self;
-
-    fn overflowing_add(&self, rhs: &PrimitiveArray<T>) -> Result<(Self::Output, Bitmap)> {
+    fn overflowing_add(&self, rhs: &PrimitiveArray<T>) -> Result<(Self, Bitmap)> {
         overflowing_add(self, rhs)
     }
 }
@@ -333,9 +323,7 @@ impl<T> ArrayAdd<T> for PrimitiveArray<T>
 where
     T: NativeArithmetics + Add<Output = T>,
 {
-    type Output = Self;
-
-    fn add(&self, rhs: &T) -> Result<Self::Output> {
+    fn add(&self, rhs: &T) -> Result<Self> {
         Ok(add_scalar(self, rhs))
     }
 }
@@ -345,9 +333,7 @@ impl<T> ArrayCheckedAdd<T> for PrimitiveArray<T>
 where
     T: NativeArithmetics + CheckedAdd<Output = T> + Zero,
 {
-    type Output = Self;
-
-    fn checked_add(&self, rhs: &T) -> Result<Self::Output> {
+    fn checked_add(&self, rhs: &T) -> Result<Self> {
         Ok(checked_add_scalar(self, rhs))
     }
 }
@@ -357,9 +343,7 @@ impl<T> ArraySaturatingAdd<T> for PrimitiveArray<T>
 where
     T: NativeArithmetics + SaturatingAdd<Output = T>,
 {
-    type Output = Self;
-
-    fn saturating_add(&self, rhs: &T) -> Result<Self::Output> {
+    fn saturating_add(&self, rhs: &T) -> Result<Self> {
         Ok(saturating_add_scalar(self, rhs))
     }
 }
@@ -369,9 +353,7 @@ impl<T> ArrayOverflowingAdd<T> for PrimitiveArray<T>
 where
     T: NativeArithmetics + OverflowingAdd<Output = T>,
 {
-    type Output = Self;
-
-    fn overflowing_add(&self, rhs: &T) -> Result<(Self::Output, Bitmap)> {
+    fn overflowing_add(&self, rhs: &T) -> Result<(Self, Bitmap)> {
         Ok(overflowing_add_scalar(self, rhs))
     }
 }
diff --git a/src/compute/arithmetics/basic/div.rs b/src/compute/arithmetics/basic/div.rs
index ca2f474baea..77eb7f73e41 100644
--- a/src/compute/arithmetics/basic/div.rs
+++ b/src/compute/arithmetics/basic/div.rs
@@ -82,9 +82,7 @@ impl<T> ArrayDiv<PrimitiveArray<T>> for PrimitiveArray<T>
 where
     T: NativeArithmetics + Div<Output = T>,
 {
-    type Output = Self;
-
-    fn div(&self, rhs: &PrimitiveArray<T>) -> Result<Self::Output> {
+    fn div(&self, rhs: &PrimitiveArray<T>) -> Result<Self> {
         div(self, rhs)
     }
 }
@@ -94,9 +92,7 @@ impl<T> ArrayCheckedDiv<PrimitiveArray<T>> for PrimitiveArray<T>
 where
     T: NativeArithmetics + CheckedDiv<Output = T>,
 {
-    type Output = Self;
-
-    fn checked_div(&self, rhs: &PrimitiveArray<T>) -> Result<Self::Output> {
+    fn checked_div(&self, rhs: &PrimitiveArray<T>) -> Result<Self> {
         checked_div(self, rhs)
     }
 }
@@ -212,9 +208,7 @@ impl<T> ArrayDiv<T> for PrimitiveArray<T>
 where
     T: NativeType + Div<Output = T> + NativeArithmetics + NumCast,
 {
-    type Output = Self;
-
-    fn div(&self, rhs: &T) -> Result<Self::Output> {
+    fn div(&self, rhs: &T) -> Result<Self> {
         Ok(div_scalar(self, rhs))
     }
 }
@@ -224,9 +218,7 @@ impl<T> ArrayCheckedDiv<T> for PrimitiveArray<T>
 where
     T: NativeType + CheckedDiv<Output = T> + Zero + NativeArithmetics,
 {
-    type Output = Self;
-
-    fn checked_div(&self, rhs: &T) -> Result<Self::Output> {
+    fn checked_div(&self, rhs: &T) -> Result<Self> {
         Ok(checked_div_scalar(self, rhs))
     }
 }
diff --git a/src/compute/arithmetics/basic/mul.rs b/src/compute/arithmetics/basic/mul.rs
index 1128ffad875..27145afe00b 100644
--- a/src/compute/arithmetics/basic/mul.rs
+++ b/src/compute/arithmetics/basic/mul.rs
@@ -161,9 +161,7 @@ impl<T> ArrayMul<PrimitiveArray<T>> for PrimitiveArray<T>
 where
     T: NativeArithmetics + Mul<Output = T>,
 {
-    type Output = Self;
-
-    fn mul(&self, rhs: &PrimitiveArray<T>) -> Result<Self::Output> {
+    fn mul(&self, rhs: &PrimitiveArray<T>) -> Result<Self> {
         mul(self, rhs)
     }
 }
@@ -172,9 +170,7 @@ impl<T> ArrayWrappingMul<PrimitiveArray<T>> for PrimitiveArray<T>
 where
     T: NativeArithmetics + WrappingMul<Output = T>,
 {
-    type Output = Self;
-
-    fn wrapping_mul(&self, rhs: &PrimitiveArray<T>) -> Result<Self::Output> {
+    fn wrapping_mul(&self, rhs: &PrimitiveArray<T>) -> Result<Self> {
         wrapping_mul(self, rhs)
     }
 }
@@ -184,9 +180,7 @@ impl<T> ArrayCheckedMul<PrimitiveArray<T>> for PrimitiveArray<T>
 where
     T: NativeArithmetics + CheckedMul<Output = T>,
 {
-    type Output = Self;
-
-    fn checked_mul(&self, rhs: &PrimitiveArray<T>) -> Result<Self::Output> {
+    fn checked_mul(&self, rhs: &PrimitiveArray<T>) -> Result<Self> {
         checked_mul(self, rhs)
     }
 }
@@ -196,9 +190,7 @@ impl<T> ArraySaturatingMul<PrimitiveArray<T>> for PrimitiveArray<T>
 where
     T: NativeArithmetics + SaturatingMul<Output = T>,
 {
-    type Output = Self;
-
-    fn saturating_mul(&self, rhs: &PrimitiveArray<T>) -> Result<Self::Output> {
+    fn saturating_mul(&self, rhs: &PrimitiveArray<T>) -> Result<Self> {
         saturating_mul(self, rhs)
     }
 }
@@ -208,9 +200,7 @@ impl<T> ArrayOverflowingMul<PrimitiveArray<T>> for PrimitiveArray<T>
 where
     T: NativeArithmetics + OverflowingMul<Output = T>,
 {
-    type Output = Self;
-
-    fn overflowing_mul(&self, rhs: &PrimitiveArray<T>) -> Result<(Self::Output, Bitmap)> {
+    fn overflowing_mul(&self, rhs: &PrimitiveArray<T>) -> Result<(Self, Bitmap)> {
         overflowing_mul(self, rhs)
     }
 }
@@ -333,9 +323,7 @@ impl<T> ArrayMul<T> for PrimitiveArray<T>
 where
     T: NativeType + Mul<Output = T> + NativeArithmetics,
 {
-    type Output = Self;
-
-    fn mul(&self, rhs: &T) -> Result<Self::Output> {
+    fn mul(&self, rhs: &T) -> Result<Self> {
         Ok(mul_scalar(self, rhs))
     }
 }
@@ -345,9 +333,7 @@ impl<T> ArrayCheckedMul<T> for PrimitiveArray<T>
 where
     T: NativeArithmetics + CheckedMul<Output = T>,
 {
-    type Output = Self;
-
-    fn checked_mul(&self, rhs: &T) -> Result<Self::Output> {
+    fn checked_mul(&self, rhs: &T) -> Result<Self> {
         Ok(checked_mul_scalar(self, rhs))
     }
 }
@@ -357,9 +343,7 @@ impl<T> ArraySaturatingMul<T> for PrimitiveArray<T>
 where
     T: NativeArithmetics + SaturatingMul<Output = T>,
 {
-    type Output = Self;
-
-    fn saturating_mul(&self, rhs: &T) -> Result<Self::Output> {
+    fn saturating_mul(&self, rhs: &T) -> Result<Self> {
         Ok(saturating_mul_scalar(self, rhs))
     }
 }
@@ -369,9 +353,7 @@ impl<T> ArrayOverflowingMul<T> for PrimitiveArray<T>
 where
     T: NativeArithmetics + OverflowingMul<Output = T>,
 {
-    type Output = Self;
-
-    fn overflowing_mul(&self, rhs: &T) -> Result<(Self::Output, Bitmap)> {
+    fn overflowing_mul(&self, rhs: &T) -> Result<(Self, Bitmap)> {
         Ok(overflowing_mul_scalar(self, rhs))
     }
 }
diff --git a/src/compute/arithmetics/basic/rem.rs b/src/compute/arithmetics/basic/rem.rs
index 8e43082def2..c39fb6359d7 100644
--- a/src/compute/arithmetics/basic/rem.rs
+++ b/src/compute/arithmetics/basic/rem.rs
@@ -70,9 +70,7 @@ impl<T> ArrayRem<PrimitiveArray<T>> for PrimitiveArray<T>
 where
     T: NativeArithmetics + Rem<Output = T>,
 {
-    type Output = Self;
-
-    fn rem(&self, rhs: &PrimitiveArray<T>) -> Result<Self::Output> {
+    fn rem(&self, rhs: &PrimitiveArray<T>) -> Result<Self> {
         rem(self, rhs)
     }
 }
@@ -81,9 +79,7 @@ impl<T> ArrayCheckedRem<PrimitiveArray<T>> for PrimitiveArray<T>
 where
     T: NativeArithmetics + CheckedRem<Output = T>,
 {
-    type Output = Self;
-
-    fn checked_rem(&self, rhs: &PrimitiveArray<T>) -> Result<Self::Output> {
+    fn checked_rem(&self, rhs: &PrimitiveArray<T>) -> Result<Self> {
         checked_rem(self, rhs)
     }
 }
@@ -199,9 +195,7 @@ impl<T> ArrayRem<T> for PrimitiveArray<T>
 where
     T: NativeArithmetics + Rem<Output = T> + NumCast,
 {
-    type Output = Self;
-
-    fn rem(&self, rhs: &T) -> Result<Self::Output> {
+    fn rem(&self, rhs: &T) -> Result<Self> {
         Ok(rem_scalar(self, rhs))
     }
 }
@@ -210,9 +204,7 @@ impl<T> ArrayCheckedRem<T> for PrimitiveArray<T>
 where
     T: NativeArithmetics + CheckedRem<Output = T>,
 {
-    type Output = Self;
-
-    fn checked_rem(&self, rhs: &T) -> Result<Self::Output> {
+    fn checked_rem(&self, rhs: &T) -> Result<Self> {
         Ok(checked_rem_scalar(self, rhs))
     }
 }
diff --git a/src/compute/arithmetics/basic/sub.rs b/src/compute/arithmetics/basic/sub.rs
index 66bff91a50d..2982410508d 100644
--- a/src/compute/arithmetics/basic/sub.rs
+++ b/src/compute/arithmetics/basic/sub.rs
@@ -160,9 +160,7 @@ impl<T> ArraySub<PrimitiveArray<T>> for PrimitiveArray<T>
 where
     T: NativeArithmetics + Sub<Output = T>,
 {
-    type Output = Self;
-
-    fn sub(&self, rhs: &PrimitiveArray<T>) -> Result<Self::Output> {
+    fn sub(&self, rhs: &PrimitiveArray<T>) -> Result<Self> {
         sub(self, rhs)
     }
 }
@@ -171,9 +169,7 @@ impl<T> ArrayWrappingSub<PrimitiveArray<T>> for PrimitiveArray<T>
 where
     T: NativeArithmetics + WrappingSub<Output = T>,
 {
-    type Output = Self;
-
-    fn wrapping_sub(&self, rhs: &PrimitiveArray<T>) -> Result<Self::Output> {
+    fn wrapping_sub(&self, rhs: &PrimitiveArray<T>) -> Result<Self> {
         wrapping_sub(self, rhs)
     }
 }
@@ -183,9 +179,7 @@ impl<T> ArrayCheckedSub<PrimitiveArray<T>> for PrimitiveArray<T>
 where
     T: NativeArithmetics + CheckedSub<Output = T>,
 {
-    type Output = Self;
-
-    fn checked_sub(&self, rhs: &PrimitiveArray<T>) -> Result<Self::Output> {
+    fn checked_sub(&self, rhs: &PrimitiveArray<T>) -> Result<Self> {
         checked_sub(self, rhs)
     }
 }
@@ -195,9 +189,7 @@ impl<T> ArraySaturatingSub<PrimitiveArray<T>> for PrimitiveArray<T>
 where
     T: NativeArithmetics + SaturatingSub<Output = T>,
 {
-    type Output = Self;
-
-    fn saturating_sub(&self, rhs: &PrimitiveArray<T>) -> Result<Self::Output> {
+    fn saturating_sub(&self, rhs: &PrimitiveArray<T>) -> Result<Self> {
         saturating_sub(self, rhs)
     }
 }
@@ -207,9 +199,7 @@ impl<T> ArrayOverflowingSub<PrimitiveArray<T>> for PrimitiveArray<T>
 where
     T: NativeArithmetics + OverflowingSub<Output = T>,
 {
-    type Output = Self;
-
-    fn overflowing_sub(&self, rhs: &PrimitiveArray<T>) -> Result<(Self::Output, Bitmap)> {
+    fn overflowing_sub(&self, rhs: &PrimitiveArray<T>) -> Result<(Self, Bitmap)> {
         overflowing_sub(self, rhs)
     }
 }
@@ -333,9 +323,7 @@ impl<T> ArraySub<T> for PrimitiveArray<T>
 where
     T: NativeArithmetics + Sub<Output = T>,
 {
-    type Output = Self;
-
-    fn sub(&self, rhs: &T) -> Result<Self::Output> {
+    fn sub(&self, rhs: &T) -> Result<Self> {
         Ok(sub_scalar(self, rhs))
     }
 }
@@ -345,9 +333,7 @@ impl<T> ArrayCheckedSub<T> for PrimitiveArray<T>
 where
     T: NativeArithmetics + CheckedSub<Output = T>,
 {
-    type Output = Self;
-
-    fn checked_sub(&self, rhs: &T) -> Result<Self::Output> {
+    fn checked_sub(&self, rhs: &T) -> Result<Self> {
         Ok(checked_sub_scalar(self, rhs))
     }
 }
@@ -357,9 +343,7 @@ impl<T> ArraySaturatingSub<T> for PrimitiveArray<T>
 where
     T: NativeArithmetics + SaturatingSub<Output = T>,
 {
-    type Output = Self;
-
-    fn saturating_sub(&self, rhs: &T) -> Result<Self::Output> {
+    fn saturating_sub(&self, rhs: &T) -> Result<Self> {
         Ok(saturating_sub_scalar(self, rhs))
     }
 }
@@ -369,9 +353,7 @@ impl<T> ArrayOverflowingSub<T> for PrimitiveArray<T>
 where
     T: NativeArithmetics + OverflowingSub<Output = T>,
 {
-    type Output = Self;
-
-    fn overflowing_sub(&self, rhs: &T) -> Result<(Self::Output, Bitmap)> {
+    fn overflowing_sub(&self, rhs: &T) -> Result<(Self, Bitmap)> {
         Ok(overflowing_sub_scalar(self, rhs))
     }
 }
diff --git a/src/compute/arithmetics/decimal/add.rs b/src/compute/arithmetics/decimal/add.rs
index 9877af9ca7a..958b737076a 100644
--- a/src/compute/arithmetics/decimal/add.rs
+++ b/src/compute/arithmetics/decimal/add.rs
@@ -202,27 +202,21 @@ pub fn checked_add(
 
 // Implementation of ArrayAdd trait for PrimitiveArrays
 impl ArrayAdd<PrimitiveArray<i128>> for PrimitiveArray<i128> {
-    type Output = Self;
-
-    fn add(&self, rhs: &PrimitiveArray<i128>) -> Result<Self::Output> {
+    fn add(&self, rhs: &PrimitiveArray<i128>) -> Result<Self> {
         add(self, rhs)
     }
 }
 
 // Implementation of ArrayCheckedAdd trait for PrimitiveArrays
 impl ArrayCheckedAdd<PrimitiveArray<i128>> for PrimitiveArray<i128> {
-    type Output = Self;
-
-    fn checked_add(&self, rhs: &PrimitiveArray<i128>) -> Result<Self::Output> {
+    fn checked_add(&self, rhs: &PrimitiveArray<i128>) -> Result<Self> {
         checked_add(self, rhs)
     }
 }
 
 // Implementation of ArraySaturatingAdd trait for PrimitiveArrays
 impl ArraySaturatingAdd<PrimitiveArray<i128>> for PrimitiveArray<i128> {
-    type Output = Self;
-
-    fn saturating_add(&self, rhs: &PrimitiveArray<i128>) -> Result<Self::Output> {
+    fn saturating_add(&self, rhs: &PrimitiveArray<i128>) -> Result<Self> {
         saturating_add(self, rhs)
     }
 }
diff --git a/src/compute/arithmetics/decimal/div.rs b/src/compute/arithmetics/decimal/div.rs
index dde60d3a1ab..961fb1988e0 100644
--- a/src/compute/arithmetics/decimal/div.rs
+++ b/src/compute/arithmetics/decimal/div.rs
@@ -226,18 +226,14 @@ pub fn checked_div(
 
 // Implementation of ArrayDiv trait for PrimitiveArrays
 impl ArrayDiv<PrimitiveArray<i128>> for PrimitiveArray<i128> {
-    type Output = Self;
-
-    fn div(&self, rhs: &PrimitiveArray<i128>) -> Result<Self::Output> {
+    fn div(&self, rhs: &PrimitiveArray<i128>) -> Result<Self> {
         div(self, rhs)
     }
 }
 
 // Implementation of ArrayCheckedDiv trait for PrimitiveArrays
 impl ArrayCheckedDiv<PrimitiveArray<i128>> for PrimitiveArray<i128> {
-    type Output = Self;
-
-    fn checked_div(&self, rhs: &PrimitiveArray<i128>) -> Result<Self::Output> {
+    fn checked_div(&self, rhs: &PrimitiveArray<i128>) -> Result<Self> {
         checked_div(self, rhs)
     }
 }
diff --git a/src/compute/arithmetics/decimal/mul.rs b/src/compute/arithmetics/decimal/mul.rs
index 8c9fa321fb4..cf4f6ac0c8f 100644
--- a/src/compute/arithmetics/decimal/mul.rs
+++ b/src/compute/arithmetics/decimal/mul.rs
@@ -222,27 +222,21 @@ pub fn checked_mul(
 
 // Implementation of ArrayMul trait for PrimitiveArrays
 impl ArrayMul<PrimitiveArray<i128>> for PrimitiveArray<i128> {
-    type Output = Self;
-
-    fn mul(&self, rhs: &PrimitiveArray<i128>) -> Result<Self::Output> {
+    fn mul(&self, rhs: &PrimitiveArray<i128>) -> Result<Self> {
         mul(self, rhs)
     }
 }
 
 // Implementation of ArrayCheckedMul trait for PrimitiveArrays
 impl ArrayCheckedMul<PrimitiveArray<i128>> for PrimitiveArray<i128> {
-    type Output = Self;
-
-    fn checked_mul(&self, rhs: &PrimitiveArray<i128>) -> Result<Self::Output> {
+    fn checked_mul(&self, rhs: &PrimitiveArray<i128>) -> Result<Self> {
         checked_mul(self, rhs)
     }
 }
 
 // Implementation of ArraySaturatingMul trait for PrimitiveArrays
 impl ArraySaturatingMul<PrimitiveArray<i128>> for PrimitiveArray<i128> {
-    type Output = Self;
-
-    fn saturating_mul(&self, rhs: &PrimitiveArray<i128>) -> Result<Self::Output> {
+    fn saturating_mul(&self, rhs: &PrimitiveArray<i128>) -> Result<Self> {
         saturating_mul(self, rhs)
     }
 }
diff --git a/src/compute/arithmetics/decimal/sub.rs b/src/compute/arithmetics/decimal/sub.rs
index 7d97e019dc0..6fb40a36ac7 100644
--- a/src/compute/arithmetics/decimal/sub.rs
+++ b/src/compute/arithmetics/decimal/sub.rs
@@ -148,27 +148,21 @@ pub fn saturating_sub(
 
 // Implementation of ArraySub trait for PrimitiveArrays
 impl ArraySub<PrimitiveArray<i128>> for PrimitiveArray<i128> {
-    type Output = Self;
-
-    fn sub(&self, rhs: &PrimitiveArray<i128>) -> Result<Self::Output> {
+    fn sub(&self, rhs: &PrimitiveArray<i128>) -> Result<Self> {
         sub(self, rhs)
     }
 }
 
 // Implementation of ArrayCheckedSub trait for PrimitiveArrays
 impl ArrayCheckedSub<PrimitiveArray<i128>> for PrimitiveArray<i128> {
-    type Output = Self;
-
-    fn checked_sub(&self, rhs: &PrimitiveArray<i128>) -> Result<Self::Output> {
+    fn checked_sub(&self, rhs: &PrimitiveArray<i128>) -> Result<Self> {
         checked_sub(self, rhs)
     }
 }
 
 // Implementation of ArraySaturatingSub trait for PrimitiveArrays
 impl ArraySaturatingSub<PrimitiveArray<i128>> for PrimitiveArray<i128> {
-    type Output = Self;
-
-    fn saturating_sub(&self, rhs: &PrimitiveArray<i128>) -> Result<Self::Output> {
+    fn saturating_sub(&self, rhs: &PrimitiveArray<i128>) -> Result<Self> {
         saturating_sub(self, rhs)
     }
 }
diff --git a/src/compute/arithmetics/mod.rs b/src/compute/arithmetics/mod.rs
index 4c798214298..d1e9fc34717 100644
--- a/src/compute/arithmetics/mod.rs
+++ b/src/compute/arithmetics/mod.rs
@@ -224,12 +224,18 @@ pub fn can_arithmetic(lhs: &DataType, op: Operator, rhs: &DataType) -> bool {
     )
 }
 
+/// Arithmetic operator
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum Operator {
+    /// Add
     Add,
+    /// Subtract
     Subtract,
+    /// Multiply
     Multiply,
+    /// Divide
     Divide,
+    /// Remainder
     Remainder,
 }
 
@@ -342,136 +348,117 @@ where
 }
 
 /// Defines basic addition operation for primitive arrays
-pub trait ArrayAdd<Rhs> {
-    type Output;
-
-    fn add(&self, rhs: &Rhs) -> Result<Self::Output>;
+pub trait ArrayAdd<Rhs>: Sized {
+    /// Adds itself to `rhs`
+    fn add(&self, rhs: &Rhs) -> Result<Self>;
 }
 
 /// Defines wrapping addition operation for primitive arrays
-pub trait ArrayWrappingAdd<Rhs> {
-    type Output;
-
-    fn wrapping_add(&self, rhs: &Rhs) -> Result<Self::Output>;
+pub trait ArrayWrappingAdd<Rhs>: Sized {
+    /// Adds itself to `rhs` using wrapping addition
+    fn wrapping_add(&self, rhs: &Rhs) -> Result<Self>;
 }
 
 /// Defines checked addition operation for primitive arrays
-pub trait ArrayCheckedAdd<Rhs> {
-    type Output;
-
-    fn checked_add(&self, rhs: &Rhs) -> Result<Self::Output>;
+pub trait ArrayCheckedAdd<Rhs>: Sized {
+    /// Checked add
+    fn checked_add(&self, rhs: &Rhs) -> Result<Self>;
 }
 
 /// Defines saturating addition operation for primitive arrays
-pub trait ArraySaturatingAdd<Rhs> {
-    type Output;
-
-    fn saturating_add(&self, rhs: &Rhs) -> Result<Self::Output>;
+pub trait ArraySaturatingAdd<Rhs>: Sized {
+    /// Saturating add
+    fn saturating_add(&self, rhs: &Rhs) -> Result<Self>;
 }
 
 /// Defines Overflowing addition operation for primitive arrays
-pub trait ArrayOverflowingAdd<Rhs> {
-    type Output;
-
-    fn overflowing_add(&self, rhs: &Rhs) -> Result<(Self::Output, Bitmap)>;
+pub trait ArrayOverflowingAdd<Rhs>: Sized {
+    /// Overflowing add
+    fn overflowing_add(&self, rhs: &Rhs) -> Result<(Self, Bitmap)>;
 }
 
 /// Defines basic subtraction operation for primitive arrays
-pub trait ArraySub<Rhs> {
-    type Output;
-
-    fn sub(&self, rhs: &Rhs) -> Result<Self::Output>;
+pub trait ArraySub<Rhs>: Sized {
+    /// subtraction
+    fn sub(&self, rhs: &Rhs) -> Result<Self>;
 }
 
 /// Defines wrapping subtraction operation for primitive arrays
-pub trait ArrayWrappingSub<Rhs> {
-    type Output;
-
-    fn wrapping_sub(&self, rhs: &Rhs) -> Result<Self::Output>;
+pub trait ArrayWrappingSub<Rhs>: Sized {
+    /// wrapping subtraction
+    fn wrapping_sub(&self, rhs: &Rhs) -> Result<Self>;
 }
 
 /// Defines checked subtraction operation for primitive arrays
-pub trait ArrayCheckedSub<Rhs> {
-    type Output;
-
-    fn checked_sub(&self, rhs: &Rhs) -> Result<Self::Output>;
+pub trait ArrayCheckedSub<Rhs>: Sized {
+    /// checked subtraction
+    fn checked_sub(&self, rhs: &Rhs) -> Result<Self>;
 }
 
 /// Defines saturating subtraction operation for primitive arrays
-pub trait ArraySaturatingSub<Rhs> {
-    type Output;
-
-    fn saturating_sub(&self, rhs: &Rhs) -> Result<Self::Output>;
+pub trait ArraySaturatingSub<Rhs>: Sized {
+    /// saturarting subtraction
+    fn saturating_sub(&self, rhs: &Rhs) -> Result<Self>;
 }
 
 /// Defines Overflowing subtraction operation for primitive arrays
-pub trait ArrayOverflowingSub<Rhs> {
-    type Output;
-
-    fn overflowing_sub(&self, rhs: &Rhs) -> Result<(Self::Output, Bitmap)>;
+pub trait ArrayOverflowingSub<Rhs>: Sized {
+    /// overflowing subtraction
+    fn overflowing_sub(&self, rhs: &Rhs) -> Result<(Self, Bitmap)>;
 }
 
 /// Defines basic multiplication operation for primitive arrays
-pub trait ArrayMul<Rhs> {
-    type Output;
-
-    fn mul(&self, rhs: &Rhs) -> Result<Self::Output>;
+pub trait ArrayMul<Rhs>: Sized {
+    /// multiplication
+    fn mul(&self, rhs: &Rhs) -> Result<Self>;
 }
 
 /// Defines wrapping multiplication operation for primitive arrays
-pub trait ArrayWrappingMul<Rhs> {
-    type Output;
-
-    fn wrapping_mul(&self, rhs: &Rhs) -> Result<Self::Output>;
+pub trait ArrayWrappingMul<Rhs>: Sized {
+    /// wrapping multiplication
+    fn wrapping_mul(&self, rhs: &Rhs) -> Result<Self>;
 }
 
 /// Defines checked multiplication operation for primitive arrays
-pub trait ArrayCheckedMul<Rhs> {
-    type Output;
-
-    fn checked_mul(&self, rhs: &Rhs) -> Result<Self::Output>;
+pub trait ArrayCheckedMul<Rhs>: Sized {
+    /// checked multiplication
+    fn checked_mul(&self, rhs: &Rhs) -> Result<Self>;
 }
 
 /// Defines saturating multiplication operation for primitive arrays
-pub trait ArraySaturatingMul<Rhs> {
-    type Output;
-
-    fn saturating_mul(&self, rhs: &Rhs) -> Result<Self::Output>;
+pub trait ArraySaturatingMul<Rhs>: Sized {
+    /// saturating multiplication
+    fn saturating_mul(&self, rhs: &Rhs) -> Result<Self>;
 }
 
 /// Defines Overflowing multiplication operation for primitive arrays
-pub trait ArrayOverflowingMul<Rhs> {
-    type Output;
-
-    fn overflowing_mul(&self, rhs: &Rhs) -> Result<(Self::Output, Bitmap)>;
+pub trait ArrayOverflowingMul<Rhs>: Sized {
+    /// overflowing multiplication
+    fn overflowing_mul(&self, rhs: &Rhs) -> Result<(Self, Bitmap)>;
 }
 
 /// Defines basic division operation for primitive arrays
-pub trait ArrayDiv<Rhs> {
-    type Output;
-
-    fn div(&self, rhs: &Rhs) -> Result<Self::Output>;
+pub trait ArrayDiv<Rhs>: Sized {
+    /// division
+    fn div(&self, rhs: &Rhs) -> Result<Self>;
 }
 
 /// Defines checked division operation for primitive arrays
-pub trait ArrayCheckedDiv<Rhs> {
-    type Output;
-
-    fn checked_div(&self, rhs: &Rhs) -> Result<Self::Output>;
+pub trait ArrayCheckedDiv<Rhs>: Sized {
+    /// checked division
+    fn checked_div(&self, rhs: &Rhs) -> Result<Self>;
 }
 
 /// Defines basic reminder operation for primitive arrays
-pub trait ArrayRem<Rhs> {
-    type Output;
-
-    fn rem(&self, rhs: &Rhs) -> Result<Self::Output>;
+pub trait ArrayRem<Rhs>: Sized {
+    /// remainder
+    fn rem(&self, rhs: &Rhs) -> Result<Self>;
 }
 
 /// Defines checked reminder operation for primitive arrays
-pub trait ArrayCheckedRem<Rhs> {
-    type Output;
-
-    fn checked_rem(&self, rhs: &Rhs) -> Result<Self::Output>;
+pub trait ArrayCheckedRem<Rhs>: Sized {
+    /// checked remainder
+    fn checked_rem(&self, rhs: &Rhs) -> Result<Self>;
 }
 
 /// Trait describing a [`NativeType`] whose semantics of arithmetic in Arrow equals
diff --git a/src/compute/bitwise.rs b/src/compute/bitwise.rs
index 127c3cc9344..e4c0d035d34 100644
--- a/src/compute/bitwise.rs
+++ b/src/compute/bitwise.rs
@@ -1,3 +1,4 @@
+//! Contains bitwise operators: [`or`], [`and`], [`xor`] and [`not`].
 use std::ops::{BitAnd, BitOr, BitXor, Not};
 
 use crate::array::{Array, PrimitiveArray};
@@ -17,7 +18,7 @@ where
     binary(lhs, rhs, lhs.data_type().clone(), |a, b| a | b)
 }
 
-/// Performs `XOR` operation on two arrays.
+/// Performs `XOR` operation between two arrays.
 /// # Error
 /// This function errors when the arrays have different lengths or are different types.
 pub fn xor<T>(lhs: &PrimitiveArray<T>, rhs: &PrimitiveArray<T>) -> Result<PrimitiveArray<T>>
@@ -39,11 +40,11 @@ where
     binary(lhs, rhs, lhs.data_type().clone(), |a, b| a & b)
 }
 
-/// Performs `OR` operation on one array.
-pub fn not<T>(arr: &PrimitiveArray<T>) -> PrimitiveArray<T>
+/// Returns a new [`PrimitiveArray`] with the bitwise `not`.
+pub fn not<T>(array: &PrimitiveArray<T>) -> PrimitiveArray<T>
 where
     T: NativeType + Not<Output = T>,
 {
     let op = move |a: T| !a;
-    unary(arr, op, arr.data_type().clone())
+    unary(array, op, array.data_type().clone())
 }
diff --git a/src/compute/hash.rs b/src/compute/hash.rs
index 25b6c0f91e6..eb61872caef 100644
--- a/src/compute/hash.rs
+++ b/src/compute/hash.rs
@@ -1,4 +1,6 @@
 //! Contains the [`hash`] and typed (e.g. [`hash_primitive`]) operators.
+//! // multiversion does not copy documentation, causing a false positive
+#![allow(missing_docs)]
 use ahash::{CallHasher, RandomState};
 use multiversion::multiversion;
 use std::hash::Hash;
diff --git a/src/compute/mod.rs b/src/compute/mod.rs
index a48b87d18e4..ab20499b5ff 100644
--- a/src/compute/mod.rs
+++ b/src/compute/mod.rs
@@ -1,3 +1,4 @@
+#![deny(missing_docs)]
 //! contains a wide range of compute operations (e.g.
 //! [`arithmetics`], [`aggregate`],
 //! [`filter`], [`comparison`], and [`sort`])