diff --git a/src/algorithm/mod.rs b/src/algorithm/mod.rs
index e7fe2a783..def42fbf0 100644
--- a/src/algorithm/mod.rs
+++ b/src/algorithm/mod.rs
@@ -150,12 +150,10 @@ macro_rules! dim_reduce_func_def {
             T: HasAfEnum,
             $out_type: HasAfEnum,
         {
-            unsafe {
-                let mut temp: af_array = std::ptr::null_mut();
-                let err_val = $ffi_name(&mut temp as *mut af_array, input.get(), dim);
-                HANDLE_ERROR(AfError::from(err_val));
-                temp.into()
-            }
+            let mut temp: af_array = std::ptr::null_mut();
+            let err_val = unsafe { $ffi_name(&mut temp as *mut af_array, input.get(), dim) };
+            HANDLE_ERROR(AfError::from(err_val));
+            temp.into()
         }
     };
 }
@@ -490,12 +488,10 @@ where
     T: HasAfEnum,
     T::AggregateOutType: HasAfEnum,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_sum_nan(&mut temp as *mut af_array, input.get(), dim, nanval);
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe { af_sum_nan(&mut temp as *mut af_array, input.get(), dim, nanval) };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Product of elements along specific dimension using user specified value instead of `NAN` values
@@ -516,12 +512,10 @@ where
     T: HasAfEnum,
     T::ProductOutType: HasAfEnum,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_product_nan(&mut temp as *mut af_array, input.get(), dim, nanval);
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe { af_product_nan(&mut temp as *mut af_array, input.get(), dim, nanval) };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 macro_rules! all_reduce_func_def {
@@ -540,14 +534,16 @@ macro_rules! all_reduce_func_def {
         {
             let mut real: f64 = 0.0;
             let mut imag: f64 = 0.0;
-            unsafe {
-                let err_val = $ffi_name(
+
+            let err_val = unsafe {
+                $ffi_name(
                     &mut real as *mut c_double,
                     &mut imag as *mut c_double,
                     input.get(),
-                );
-                HANDLE_ERROR(AfError::from(err_val));
-            }
+                )
+            };
+            HANDLE_ERROR(AfError::from(err_val));
+
             (
                 <<T as HasAfEnum>::$assoc_type as HasAfEnum>::BaseType::fromf64(real),
                 <<T as HasAfEnum>::$assoc_type as HasAfEnum>::BaseType::fromf64(imag),
@@ -683,14 +679,16 @@ macro_rules! all_reduce_func_def2 {
         {
             let mut real: f64 = 0.0;
             let mut imag: f64 = 0.0;
-            unsafe {
-                let err_val = $ffi_name(
+
+            let err_val = unsafe {
+                $ffi_name(
                     &mut real as *mut c_double,
                     &mut imag as *mut c_double,
                     input.get(),
-                );
-                HANDLE_ERROR(AfError::from(err_val));
-            }
+                )
+            };
+            HANDLE_ERROR(AfError::from(err_val));
+
             (<$out_type>::fromf64(real), <$out_type>::fromf64(imag))
         }
     };
@@ -806,15 +804,17 @@ where
 {
     let mut real: f64 = 0.0;
     let mut imag: f64 = 0.0;
-    unsafe {
-        let err_val = af_sum_nan_all(
+
+    let err_val = unsafe {
+        af_sum_nan_all(
             &mut real as *mut c_double,
             &mut imag as *mut c_double,
             input.get(),
             val,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+
     (
         <<T as HasAfEnum>::AggregateOutType as HasAfEnum>::BaseType::fromf64(real),
         <<T as HasAfEnum>::AggregateOutType as HasAfEnum>::BaseType::fromf64(imag),
@@ -850,15 +850,17 @@ where
 {
     let mut real: f64 = 0.0;
     let mut imag: f64 = 0.0;
-    unsafe {
-        let err_val = af_product_nan_all(
+
+    let err_val = unsafe {
+        af_product_nan_all(
             &mut real as *mut c_double,
             &mut imag as *mut c_double,
             input.get(),
             val,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+
     (
         <<T as HasAfEnum>::ProductOutType as HasAfEnum>::BaseType::fromf64(real),
         <<T as HasAfEnum>::ProductOutType as HasAfEnum>::BaseType::fromf64(imag),
@@ -873,18 +875,18 @@ macro_rules! dim_ireduce_func_def {
             T: HasAfEnum,
             T::$out_type: HasAfEnum,
         {
-            unsafe {
-                let mut temp: af_array = std::ptr::null_mut();
-                let mut idx: af_array = std::ptr::null_mut();
-                let err_val = $ffi_name(
+            let mut temp: af_array = std::ptr::null_mut();
+            let mut idx: af_array = std::ptr::null_mut();
+            let err_val = unsafe {
+                $ffi_name(
                     &mut temp as *mut af_array,
                     &mut idx as *mut af_array,
                     input.get(),
                     dim,
-                );
-                HANDLE_ERROR(AfError::from(err_val));
-                (temp.into(), idx.into())
-            }
+                )
+            };
+            HANDLE_ERROR(AfError::from(err_val));
+            (temp.into(), idx.into())
         }
     };
 }
@@ -933,15 +935,17 @@ macro_rules! all_ireduce_func_def {
             let mut real: f64 = 0.0;
             let mut imag: f64 = 0.0;
             let mut temp: u32 = 0;
-            unsafe {
-                let err_val = $ffi_name(
+
+            let err_val = unsafe {
+                $ffi_name(
                     &mut real as *mut c_double,
                     &mut imag as *mut c_double,
                     &mut temp as *mut c_uint,
                     input.get(),
-                );
-                HANDLE_ERROR(AfError::from(err_val));
-            }
+                )
+            };
+            HANDLE_ERROR(AfError::from(err_val));
+
             (
                 <<T as HasAfEnum>::$assoc_type as HasAfEnum>::BaseType::fromf64(real),
                 <<T as HasAfEnum>::$assoc_type as HasAfEnum>::BaseType::fromf64(imag),
@@ -1004,12 +1008,10 @@ all_ireduce_func_def!(
 ///
 /// Array of indices where the input Array has non-zero values.
 pub fn locate<T: HasAfEnum>(input: &Array<T>) -> Array<u32> {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_where(&mut temp as *mut af_array, input.get());
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe { af_where(&mut temp as *mut af_array, input.get()) };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Sort the values in input Arrays
@@ -1030,12 +1032,10 @@ pub fn sort<T>(input: &Array<T>, dim: u32, ascending: bool) -> Array<T>
 where
     T: HasAfEnum + RealNumber,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_sort(&mut temp as *mut af_array, input.get(), dim, ascending);
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe { af_sort(&mut temp as *mut af_array, input.get(), dim, ascending) };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Sort the values in input Arrays
@@ -1058,19 +1058,19 @@ pub fn sort_index<T>(input: &Array<T>, dim: u32, ascending: bool) -> (Array<T>,
 where
     T: HasAfEnum + RealNumber,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let mut idx: af_array = std::ptr::null_mut();
-        let err_val = af_sort_index(
+    let mut temp: af_array = std::ptr::null_mut();
+    let mut idx: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_sort_index(
             &mut temp as *mut af_array,
             &mut idx as *mut af_array,
             input.get(),
             dim,
             ascending,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        (temp.into(), idx.into())
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    (temp.into(), idx.into())
 }
 
 /// Sort the values in input Arrays
@@ -1101,20 +1101,20 @@ where
     K: HasAfEnum + RealNumber,
     V: HasAfEnum,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let mut temp2: af_array = std::ptr::null_mut();
-        let err_val = af_sort_by_key(
+    let mut temp: af_array = std::ptr::null_mut();
+    let mut temp2: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_sort_by_key(
             &mut temp as *mut af_array,
             &mut temp2 as *mut af_array,
             keys.get(),
             vals.get(),
             dim,
             ascending,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        (temp.into(), temp2.into())
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    (temp.into(), temp2.into())
 }
 
 /// Find unique values from a Set
@@ -1132,12 +1132,10 @@ pub fn set_unique<T>(input: &Array<T>, is_sorted: bool) -> Array<T>
 where
     T: HasAfEnum + RealNumber,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_set_unique(&mut temp as *mut af_array, input.get(), is_sorted);
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe { af_set_unique(&mut temp as *mut af_array, input.get(), is_sorted) };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Find union of two sets
@@ -1155,17 +1153,17 @@ pub fn set_union<T>(first: &Array<T>, second: &Array<T>, is_unique: bool) -> Arr
 where
     T: HasAfEnum + RealNumber,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_set_union(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_set_union(
             &mut temp as *mut af_array,
             first.get(),
             second.get(),
             is_unique,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Find intersection of two sets
@@ -1183,17 +1181,17 @@ pub fn set_intersect<T>(first: &Array<T>, second: &Array<T>, is_unique: bool) ->
 where
     T: HasAfEnum + RealNumber,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_set_intersect(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_set_intersect(
             &mut temp as *mut af_array,
             first.get(),
             second.get(),
             is_unique,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Generalized scan
@@ -1219,18 +1217,18 @@ where
     T: HasAfEnum,
     T::AggregateOutType: HasAfEnum,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_scan(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_scan(
             &mut temp as *mut af_array,
             input.get(),
             dim,
             op as u32,
             inclusive,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Generalized scan by key
@@ -1259,19 +1257,19 @@ where
     V::AggregateOutType: HasAfEnum,
     K: HasAfEnum + Scanable,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_scan_by_key(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_scan_by_key(
             &mut temp as *mut af_array,
             key.get(),
             input.get(),
             dim,
             op as u32,
             inclusive,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 macro_rules! dim_reduce_by_key_func_def {
@@ -1298,19 +1296,19 @@ macro_rules! dim_reduce_by_key_func_def {
             ValueType: HasAfEnum,
             $out_type: HasAfEnum,
         {
-            unsafe {
-                let mut out_keys: af_array = std::ptr::null_mut();
-                let mut out_vals: af_array = std::ptr::null_mut();
-                let err_val = $ffi_name(
+            let mut out_keys: af_array = std::ptr::null_mut();
+            let mut out_vals: af_array = std::ptr::null_mut();
+            let err_val = unsafe {
+                $ffi_name(
                     &mut out_keys as *mut af_array,
                     &mut out_vals as *mut af_array,
                     keys.get(),
                     vals.get(),
                     dim,
-                );
-                HANDLE_ERROR(AfError::from(err_val));
-                (out_keys.into(), out_vals.into())
-            }
+                )
+            };
+            HANDLE_ERROR(AfError::from(err_val));
+            (out_keys.into(), out_vals.into())
         }
     };
 }
@@ -1435,20 +1433,20 @@ macro_rules! dim_reduce_by_key_nan_func_def {
             ValueType: HasAfEnum,
             $out_type: HasAfEnum,
         {
-            unsafe {
-                let mut out_keys: af_array = std::ptr::null_mut();
-                let mut out_vals: af_array = std::ptr::null_mut();
-                let err_val = $ffi_name(
+            let mut out_keys: af_array = std::ptr::null_mut();
+            let mut out_vals: af_array = std::ptr::null_mut();
+            let err_val = unsafe {
+                $ffi_name(
                     &mut out_keys as *mut af_array,
                     &mut out_vals as *mut af_array,
                     keys.get(),
                     vals.get(),
                     dim,
                     replace_value,
-                );
-                HANDLE_ERROR(AfError::from(err_val));
-                (out_keys.into(), out_vals.into())
-            }
+                )
+            };
+            HANDLE_ERROR(AfError::from(err_val));
+            (out_keys.into(), out_vals.into())
         }
     };
 }
@@ -1514,19 +1512,19 @@ where
     T: HasAfEnum,
     T::InType: HasAfEnum,
 {
-    unsafe {
-        let mut out_vals: af_array = std::ptr::null_mut();
-        let mut out_idxs: af_array = std::ptr::null_mut();
-        let err_val = af_max_ragged(
+    let mut out_vals: af_array = std::ptr::null_mut();
+    let mut out_idxs: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_max_ragged(
             &mut out_vals as *mut af_array,
             &mut out_idxs as *mut af_array,
             input.get(),
             ragged_len.get(),
             dim,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        (out_vals.into(), out_idxs.into())
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    (out_vals.into(), out_idxs.into())
 }
 
 #[cfg(test)]
diff --git a/src/blas/mod.rs b/src/blas/mod.rs
index 419799356..040858e46 100644
--- a/src/blas/mod.rs
+++ b/src/blas/mod.rs
@@ -130,9 +130,9 @@ pub fn gemm<T>(
 ) where
     T: HasAfEnum + FloatingPoint,
 {
-    unsafe {
-        let mut out = output.get();
-        let err_val = af_gemm(
+    let mut out = unsafe { output.get() };
+    let err_val = unsafe {
+        af_gemm(
             &mut out as *mut af_array,
             optlhs as c_uint,
             optrhs as c_uint,
@@ -140,10 +140,10 @@ pub fn gemm<T>(
             lhs.get(),
             rhs.get(),
             beta.as_ptr() as *const c_void,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        output.set(out);
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    output.set(out);
 }
 
 /// Matrix multiple of two Arrays
@@ -162,18 +162,18 @@ pub fn matmul<T>(lhs: &Array<T>, rhs: &Array<T>, optlhs: MatProp, optrhs: MatPro
 where
     T: HasAfEnum + FloatingPoint,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_matmul(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_matmul(
             &mut temp as *mut af_array,
             lhs.get(),
             rhs.get(),
             optlhs as c_uint,
             optrhs as c_uint,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Calculate the dot product of vectors.
@@ -194,18 +194,18 @@ pub fn dot<T>(lhs: &Array<T>, rhs: &Array<T>, optlhs: MatProp, optrhs: MatProp)
 where
     T: HasAfEnum + FloatingPoint,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_dot(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_dot(
             &mut temp as *mut af_array,
             lhs.get(),
             rhs.get(),
             optlhs as c_uint,
             optrhs as c_uint,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Transpose of a matrix.
@@ -220,12 +220,10 @@ where
 ///
 /// Transposed Array.
 pub fn transpose<T: HasAfEnum>(arr: &Array<T>, conjugate: bool) -> Array<T> {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_transpose(&mut temp as *mut af_array, arr.get(), conjugate);
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe { af_transpose(&mut temp as *mut af_array, arr.get(), conjugate) };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Inplace transpose of a matrix.
@@ -236,10 +234,8 @@ pub fn transpose<T: HasAfEnum>(arr: &Array<T>, conjugate: bool) -> Array<T> {
 /// - `conjugate` is a boolean that indicates if the transpose operation needs to be a conjugate
 /// transpose
 pub fn transpose_inplace<T: HasAfEnum>(arr: &mut Array<T>, conjugate: bool) {
-    unsafe {
-        let err_val = af_transpose_inplace(arr.get(), conjugate);
-        HANDLE_ERROR(AfError::from(err_val));
-    }
+    let err_val = unsafe { af_transpose_inplace(arr.get(), conjugate) };
+    HANDLE_ERROR(AfError::from(err_val));
 }
 
 /// Sets the cuBLAS math mode for the internal handle.
diff --git a/src/core/arith.rs b/src/core/arith.rs
index 3c7fcbd7f..d9a396293 100644
--- a/src/core/arith.rs
+++ b/src/core/arith.rs
@@ -108,12 +108,10 @@ where
     type Output = Array<T>;
 
     fn not(self) -> Self::Output {
-        unsafe {
-            let mut temp: af_array = std::ptr::null_mut();
-            let err_val = af_not(&mut temp as *mut af_array, self.get());
-            HANDLE_ERROR(AfError::from(err_val));
-            temp.into()
-        }
+        let mut temp: af_array = std::ptr::null_mut();
+        let err_val = unsafe { af_not(&mut temp as *mut af_array, self.get()) };
+        HANDLE_ERROR(AfError::from(err_val));
+        temp.into()
     }
 }
 
@@ -124,12 +122,12 @@ macro_rules! unary_func {
         /// This is an element wise unary operation.
         pub fn $fn_name<T: HasAfEnum>(input: &Array<T>) -> Array< T::$out_type >
         where T::$out_type: HasAfEnum {
-            unsafe {
+
                 let mut temp: af_array = std::ptr::null_mut();
-                let err_val = $ffi_fn(&mut temp as *mut af_array, input.get());
+                let err_val = unsafe { $ffi_fn(&mut temp as *mut af_array, input.get()) };
                 HANDLE_ERROR(AfError::from(err_val));
                 temp.into()
-            }
+
         }
     )
 }
@@ -256,12 +254,12 @@ macro_rules! unary_boolean_func {
         ///
         /// This is an element wise unary operation.
         pub fn $fn_name<T: HasAfEnum>(input: &Array<T>) -> Array<bool> {
-            unsafe {
+
                 let mut temp: af_array = std::ptr::null_mut();
-                let err_val = $ffi_fn(&mut temp as *mut af_array, input.get());
+                let err_val = unsafe { $ffi_fn(&mut temp as *mut af_array, input.get()) };
                 HANDLE_ERROR(AfError::from(err_val));
                 temp.into()
-            }
+
         }
     )
 }
@@ -291,12 +289,11 @@ macro_rules! binary_func {
             A: ImplicitPromote<B>,
             B: ImplicitPromote<A>,
         {
-            unsafe {
-                let mut temp: af_array = std::ptr::null_mut();
-                let err_val = $ffi_fn(&mut temp as *mut af_array, lhs.get(), rhs.get(), batch);
-                HANDLE_ERROR(AfError::from(err_val));
-                Into::<Array<A::Output>>::into(temp)
-            }
+            let mut temp: af_array = std::ptr::null_mut();
+            let err_val =
+                unsafe { $ffi_fn(&mut temp as *mut af_array, lhs.get(), rhs.get(), batch) };
+            HANDLE_ERROR(AfError::from(err_val));
+            Into::<Array<A::Output>>::into(temp)
         }
     };
 }
@@ -389,12 +386,11 @@ macro_rules! overloaded_binary_func {
             A: ImplicitPromote<B>,
             B: ImplicitPromote<A>,
         {
-            unsafe {
-                let mut temp: af_array = std::ptr::null_mut();
-                let err_val = $ffi_name(&mut temp as *mut af_array, lhs.get(), rhs.get(), batch);
-                HANDLE_ERROR(AfError::from(err_val));
-                temp.into()
-            }
+            let mut temp: af_array = std::ptr::null_mut();
+            let err_val =
+                unsafe { $ffi_name(&mut temp as *mut af_array, lhs.get(), rhs.get(), batch) };
+            HANDLE_ERROR(AfError::from(err_val));
+            temp.into()
         }
 
         #[doc=$doc_str]
@@ -491,12 +487,11 @@ macro_rules! overloaded_logic_func {
             A: ImplicitPromote<B>,
             B: ImplicitPromote<A>,
         {
-            unsafe {
-                let mut temp: af_array = std::ptr::null_mut();
-                let err_val = $ffi_name(&mut temp as *mut af_array, lhs.get(), rhs.get(), batch);
-                HANDLE_ERROR(AfError::from(err_val));
-                temp.into()
-            }
+            let mut temp: af_array = std::ptr::null_mut();
+            let err_val =
+                unsafe { $ffi_name(&mut temp as *mut af_array, lhs.get(), rhs.get(), batch) };
+            HANDLE_ERROR(AfError::from(err_val));
+            temp.into()
         }
 
         #[doc=$doc_str]
@@ -611,18 +606,18 @@ where
     X: ImplicitPromote<Y>,
     Y: ImplicitPromote<X>,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_clamp(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_clamp(
             &mut temp as *mut af_array,
             inp.get(),
             lo.get(),
             hi.get(),
             batch,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Clamp the values of Array
@@ -979,10 +974,8 @@ pub fn bitnot<T: HasAfEnum>(input: &Array<T>) -> Array<T>
 where
     T: HasAfEnum + IntegralType,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_bitnot(&mut temp as *mut af_array, input.get());
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe { af_bitnot(&mut temp as *mut af_array, input.get()) };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
diff --git a/src/core/array.rs b/src/core/array.rs
index fdf262bec..2a5194b56 100644
--- a/src/core/array.rs
+++ b/src/core/array.rs
@@ -235,18 +235,19 @@ where
     ///
     pub fn new(slice: &[T], dims: Dim4) -> Self {
         let aftype = T::get_af_dtype();
-        unsafe {
-            let mut temp: af_array = std::ptr::null_mut();
-            let err_val = af_create_array(
+
+        let mut temp: af_array = std::ptr::null_mut();
+        let err_val = unsafe {
+            af_create_array(
                 &mut temp as *mut af_array,
                 slice.as_ptr() as *const c_void,
                 dims.ndims() as c_uint,
                 dims.get().as_ptr() as *const c_longlong,
                 aftype as c_uint,
-            );
-            HANDLE_ERROR(AfError::from(err_val));
-            temp.into()
-        }
+            )
+        };
+        HANDLE_ERROR(AfError::from(err_val));
+        temp.into()
     }
 
     /// Constructs a new Array object from strided data
@@ -254,9 +255,10 @@ where
     /// The data pointed by the slice passed to this function can possibily be offseted using an additional `offset` parameter.
     pub fn new_strided(slice: &[T], offset: i64, dims: Dim4, strides: Dim4) -> Self {
         let aftype = T::get_af_dtype();
-        unsafe {
-            let mut temp: af_array = std::ptr::null_mut();
-            let err_val = af_create_strided_array(
+
+        let mut temp: af_array = std::ptr::null_mut();
+        let err_val = unsafe {
+            af_create_strided_array(
                 &mut temp as *mut af_array,
                 slice.as_ptr() as *const c_void,
                 offset as dim_t,
@@ -265,10 +267,10 @@ where
                 strides.get().as_ptr() as *const c_longlong,
                 aftype as c_uint,
                 1_u32,
-            );
-            HANDLE_ERROR(AfError::from(err_val));
-            temp.into()
-        }
+            )
+        };
+        HANDLE_ERROR(AfError::from(err_val));
+        temp.into()
     }
 
     /// Constructs a new Array object of specified dimensions and type
@@ -281,17 +283,18 @@ where
     /// ```
     pub fn new_empty(dims: Dim4) -> Self {
         let aftype = T::get_af_dtype();
-        unsafe {
-            let mut temp: af_array = std::ptr::null_mut();
-            let err_val = af_create_handle(
+
+        let mut temp: af_array = std::ptr::null_mut();
+        let err_val = unsafe {
+            af_create_handle(
                 &mut temp as *mut af_array,
                 dims.ndims() as c_uint,
                 dims.get().as_ptr() as *const c_longlong,
                 aftype as c_uint,
-            );
-            HANDLE_ERROR(AfError::from(err_val));
-            temp.into()
-        }
+            )
+        };
+        HANDLE_ERROR(AfError::from(err_val));
+        temp.into()
     }
 
     /// Constructs a new Array object from device pointer
@@ -367,18 +370,19 @@ where
     /// ```
     pub fn new_from_device_ptr(dev_ptr: *mut T, dims: Dim4) -> Self {
         let aftype = T::get_af_dtype();
-        unsafe {
-            let mut temp: af_array = std::ptr::null_mut();
-            let err_val = af_device_array(
+
+        let mut temp: af_array = std::ptr::null_mut();
+        let err_val = unsafe {
+            af_device_array(
                 &mut temp as *mut af_array,
                 dev_ptr as *mut c_void,
                 dims.ndims() as c_uint,
                 dims.get().as_ptr() as *const dim_t,
                 aftype as c_uint,
-            );
-            HANDLE_ERROR(AfError::from(err_val));
-            temp.into()
-        }
+            )
+        };
+        HANDLE_ERROR(AfError::from(err_val));
+        temp.into()
     }
 
     /// Returns the backend of the Array
@@ -388,16 +392,14 @@ where
     /// Returns an value of type `Backend` which indicates which backend
     /// was active when Array was created.
     pub fn get_backend(&self) -> Backend {
-        unsafe {
-            let mut ret_val: u32 = 0;
-            let err_val = af_get_backend_id(&mut ret_val as *mut c_uint, self.handle);
-            HANDLE_ERROR(AfError::from(err_val));
-            match (err_val, ret_val) {
-                (0, 1) => Backend::CPU,
-                (0, 2) => Backend::CUDA,
-                (0, 3) => Backend::OPENCL,
-                _ => Backend::DEFAULT,
-            }
+        let mut ret_val: u32 = 0;
+        let err_val = unsafe { af_get_backend_id(&mut ret_val as *mut c_uint, self.handle) };
+        HANDLE_ERROR(AfError::from(err_val));
+        match (err_val, ret_val) {
+            (0, 1) => Backend::CPU,
+            (0, 2) => Backend::CUDA,
+            (0, 3) => Backend::OPENCL,
+            _ => Backend::DEFAULT,
         }
     }
 
@@ -407,90 +409,80 @@ where
     ///
     /// Return the device id on which Array was created.
     pub fn get_device_id(&self) -> i32 {
-        unsafe {
-            let mut ret_val: i32 = 0;
-            let err_val = af_get_device_id(&mut ret_val as *mut c_int, self.handle);
-            HANDLE_ERROR(AfError::from(err_val));
-            ret_val
-        }
+        let mut ret_val: i32 = 0;
+        let err_val = unsafe { af_get_device_id(&mut ret_val as *mut c_int, self.handle) };
+        HANDLE_ERROR(AfError::from(err_val));
+        ret_val
     }
 
     /// Returns the number of elements in the Array
     pub fn elements(&self) -> usize {
-        unsafe {
-            let mut ret_val: dim_t = 0;
-            let err_val = af_get_elements(&mut ret_val as *mut dim_t, self.handle);
-            HANDLE_ERROR(AfError::from(err_val));
-            ret_val as usize
-        }
+        let mut ret_val: dim_t = 0;
+        let err_val = unsafe { af_get_elements(&mut ret_val as *mut dim_t, self.handle) };
+        HANDLE_ERROR(AfError::from(err_val));
+        ret_val as usize
     }
 
     /// Returns the Array data type
     pub fn get_type(&self) -> DType {
-        unsafe {
-            let mut ret_val: u32 = 0;
-            let err_val = af_get_type(&mut ret_val as *mut c_uint, self.handle);
-            HANDLE_ERROR(AfError::from(err_val));
-            DType::from(ret_val)
-        }
+        let mut ret_val: u32 = 0;
+        let err_val = unsafe { af_get_type(&mut ret_val as *mut c_uint, self.handle) };
+        HANDLE_ERROR(AfError::from(err_val));
+        DType::from(ret_val)
     }
 
     /// Returns the dimensions of the Array
     pub fn dims(&self) -> Dim4 {
-        unsafe {
-            let mut ret0: i64 = 0;
-            let mut ret1: i64 = 0;
-            let mut ret2: i64 = 0;
-            let mut ret3: i64 = 0;
-            let err_val = af_get_dims(
+        let mut ret0: i64 = 0;
+        let mut ret1: i64 = 0;
+        let mut ret2: i64 = 0;
+        let mut ret3: i64 = 0;
+        let err_val = unsafe {
+            af_get_dims(
                 &mut ret0 as *mut dim_t,
                 &mut ret1 as *mut dim_t,
                 &mut ret2 as *mut dim_t,
                 &mut ret3 as *mut dim_t,
                 self.handle,
-            );
-            HANDLE_ERROR(AfError::from(err_val));
-            Dim4::new(&[ret0 as u64, ret1 as u64, ret2 as u64, ret3 as u64])
-        }
+            )
+        };
+        HANDLE_ERROR(AfError::from(err_val));
+        Dim4::new(&[ret0 as u64, ret1 as u64, ret2 as u64, ret3 as u64])
     }
 
     /// Returns the strides of the Array
     pub fn strides(&self) -> Dim4 {
-        unsafe {
-            let mut ret0: i64 = 0;
-            let mut ret1: i64 = 0;
-            let mut ret2: i64 = 0;
-            let mut ret3: i64 = 0;
-            let err_val = af_get_strides(
+        let mut ret0: i64 = 0;
+        let mut ret1: i64 = 0;
+        let mut ret2: i64 = 0;
+        let mut ret3: i64 = 0;
+        let err_val = unsafe {
+            af_get_strides(
                 &mut ret0 as *mut dim_t,
                 &mut ret1 as *mut dim_t,
                 &mut ret2 as *mut dim_t,
                 &mut ret3 as *mut dim_t,
                 self.handle,
-            );
-            HANDLE_ERROR(AfError::from(err_val));
-            Dim4::new(&[ret0 as u64, ret1 as u64, ret2 as u64, ret3 as u64])
-        }
+            )
+        };
+        HANDLE_ERROR(AfError::from(err_val));
+        Dim4::new(&[ret0 as u64, ret1 as u64, ret2 as u64, ret3 as u64])
     }
 
     /// Returns the number of dimensions of the Array
     pub fn numdims(&self) -> u32 {
-        unsafe {
-            let mut ret_val: u32 = 0;
-            let err_val = af_get_numdims(&mut ret_val as *mut c_uint, self.handle);
-            HANDLE_ERROR(AfError::from(err_val));
-            ret_val
-        }
+        let mut ret_val: u32 = 0;
+        let err_val = unsafe { af_get_numdims(&mut ret_val as *mut c_uint, self.handle) };
+        HANDLE_ERROR(AfError::from(err_val));
+        ret_val
     }
 
     /// Returns the offset to the pointer from where data begins
     pub fn offset(&self) -> i64 {
-        unsafe {
-            let mut ret_val: i64 = 0;
-            let err_val = af_get_offset(&mut ret_val as *mut dim_t, self.handle);
-            HANDLE_ERROR(AfError::from(err_val));
-            ret_val
-        }
+        let mut ret_val: i64 = 0;
+        let err_val = unsafe { af_get_offset(&mut ret_val as *mut dim_t, self.handle) };
+        HANDLE_ERROR(AfError::from(err_val));
+        ret_val
     }
 
     /// Returns the native FFI handle for Rust object `Array`
@@ -533,30 +525,25 @@ where
         if data.len() != self.elements() {
             HANDLE_ERROR(AfError::ERR_SIZE);
         }
-        unsafe {
-            let err_val = af_get_data_ptr(data.as_mut_ptr() as *mut c_void, self.handle);
-            HANDLE_ERROR(AfError::from(err_val));
-        }
+
+        let err_val = unsafe { af_get_data_ptr(data.as_mut_ptr() as *mut c_void, self.handle) };
+        HANDLE_ERROR(AfError::from(err_val));
     }
 
     /// Evaluates any pending lazy expressions that represent the data in the Array object
     pub fn eval(&self) {
-        unsafe {
-            let err_val = af_eval(self.handle);
-            HANDLE_ERROR(AfError::from(err_val));
-        }
+        let err_val = unsafe { af_eval(self.handle) };
+        HANDLE_ERROR(AfError::from(err_val));
     }
 
     /// Makes an copy of the Array
     ///
     /// This does a deep copy of the data into a new Array
     pub fn copy(&self) -> Self {
-        unsafe {
-            let mut temp: af_array = std::ptr::null_mut();
-            let err_val = af_copy_array(&mut temp as *mut af_array, self.handle);
-            HANDLE_ERROR(AfError::from(err_val));
-            temp.into()
-        }
+        let mut temp: af_array = std::ptr::null_mut();
+        let err_val = unsafe { af_copy_array(&mut temp as *mut af_array, self.handle) };
+        HANDLE_ERROR(AfError::from(err_val));
+        temp.into()
     }
 
     is_func!("Check if Array is empty", is_empty, af_is_empty);
@@ -624,22 +611,20 @@ where
     /// Cast the Array data type to `target_type`
     pub fn cast<O: HasAfEnum>(&self) -> Array<O> {
         let trgt_type = O::get_af_dtype();
-        unsafe {
-            let mut temp: af_array = std::ptr::null_mut();
-            let err_val = af_cast(&mut temp as *mut af_array, self.handle, trgt_type as c_uint);
-            HANDLE_ERROR(AfError::from(err_val));
-            temp.into()
-        }
+
+        let mut temp: af_array = std::ptr::null_mut();
+        let err_val =
+            unsafe { af_cast(&mut temp as *mut af_array, self.handle, trgt_type as c_uint) };
+        HANDLE_ERROR(AfError::from(err_val));
+        temp.into()
     }
 
     /// Lock the device buffer in the memory manager
     ///
     /// Locked buffers are not freed by memory manager until unlock is called.
     pub fn lock(&self) {
-        unsafe {
-            let err_val = af_lock_array(self.handle);
-            HANDLE_ERROR(AfError::from(err_val));
-        }
+        let err_val = unsafe { af_lock_array(self.handle) };
+        HANDLE_ERROR(AfError::from(err_val));
     }
 
     /// Unlock the device buffer in the memory manager
@@ -647,10 +632,8 @@ where
     /// This function will give back the control over the device pointer to the
     /// memory manager.
     pub fn unlock(&self) {
-        unsafe {
-            let err_val = af_unlock_array(self.handle);
-            HANDLE_ERROR(AfError::from(err_val));
-        }
+        let err_val = unsafe { af_unlock_array(self.handle) };
+        HANDLE_ERROR(AfError::from(err_val));
     }
 
     /// Get the device pointer and lock the buffer in memory manager
@@ -673,32 +656,32 @@ where
     /// This function will return the size of the parent/owner if the current Array object is an
     /// indexed Array.
     pub fn get_allocated_bytes(&self) -> usize {
-        unsafe {
-            let mut temp: usize = 0;
-            let err_val = af_get_allocated_bytes(&mut temp as *mut usize, self.handle);
-            HANDLE_ERROR(AfError::from(err_val));
-            temp
-        }
+        let mut temp: usize = 0;
+        let err_val = unsafe { af_get_allocated_bytes(&mut temp as *mut usize, self.handle) };
+        HANDLE_ERROR(AfError::from(err_val));
+        temp
     }
 
     /// Fetch Array as String
     #[allow(clippy::inherent_to_string)]
     pub fn to_string(&self) -> String {
         let result: String;
-        unsafe {
-            let cname = CString::new("test").unwrap();
-            let mut tmp: *mut c_char = ::std::ptr::null_mut();
-            let err_val = af_array_to_string(
+
+        let cname = CString::new("test").unwrap();
+        let mut tmp: *mut c_char = ::std::ptr::null_mut();
+        let err_val = unsafe {
+            af_array_to_string(
                 &mut tmp,
                 cname.to_bytes_with_nul().as_ptr() as *const c_char,
                 self.get(),
                 4,
                 true,
-            );
-            HANDLE_ERROR(AfError::from(err_val));
-            result = CStr::from_ptr(tmp).to_string_lossy().into_owned();
-            free_host(tmp);
-        }
+            )
+        };
+        HANDLE_ERROR(AfError::from(err_val));
+        result = unsafe { CStr::from_ptr(tmp).to_string_lossy().into_owned() };
+        free_host(tmp);
+
         result
     }
 }
@@ -728,13 +711,11 @@ where
     T: HasAfEnum,
 {
     fn clone(&self) -> Self {
-        unsafe {
-            let mut temp: af_array = std::ptr::null_mut();
-            let ret_val = af_retain_array(&mut temp as *mut af_array, self.handle);
-            match ret_val {
-                0 => temp.into(),
-                _ => panic!("Weak copy of Array failed with error code: {}", ret_val),
-            }
+        let mut temp: af_array = std::ptr::null_mut();
+        let ret_val = unsafe { af_retain_array(&mut temp as *mut af_array, self.handle) };
+        match ret_val {
+            0 => temp.into(),
+            _ => panic!("Weak copy of Array failed with error code: {}", ret_val),
         }
     }
 }
@@ -742,12 +723,10 @@ where
 /// To free resources when Array goes out of scope
 impl<T> Drop for Array<T> {
     fn drop(&mut self) {
-        unsafe {
-            let ret_val = af_release_array(self.handle);
-            match ret_val {
-                0 => (),
-                _ => panic!("Array<T> drop failed with error code: {}", ret_val),
-            }
+        let ret_val = unsafe { af_release_array(self.handle) };
+        match ret_val {
+            0 => (),
+            _ => panic!("Array<T> drop failed with error code: {}", ret_val),
         }
     }
 }
@@ -780,14 +759,15 @@ impl<T> Drop for Array<T> {
 /// ```
 pub fn print<T: HasAfEnum>(input: &Array<T>) {
     let emptystring = CString::new("").unwrap();
-    unsafe {
-        let err_val = af_print_array_gen(
+
+    let err_val = unsafe {
+        af_print_array_gen(
             emptystring.to_bytes_with_nul().as_ptr() as *const c_char,
             input.get(),
             4,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
 }
 
 /// Generalized Array print function
@@ -824,14 +804,15 @@ pub fn print<T: HasAfEnum>(input: &Array<T>) {
 /// ```
 pub fn print_gen<T: HasAfEnum>(msg: String, input: &Array<T>, precision: Option<i32>) {
     let emptystring = CString::new(msg.as_bytes()).unwrap();
-    unsafe {
-        let err_val = af_print_array_gen(
+
+    let err_val = unsafe {
+        af_print_array_gen(
             emptystring.to_bytes_with_nul().as_ptr() as *const c_char,
             input.get(),
             precision.unwrap_or(4),
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
 }
 
 /// evaluate multiple arrays
@@ -842,15 +823,13 @@ pub fn print_gen<T: HasAfEnum>(msg: String, input: &Array<T>, precision: Option<
 ///
 /// - `inputs` are the list of arrays to be evaluated
 pub fn eval_multiple<T: HasAfEnum>(inputs: Vec<&Array<T>>) {
-    unsafe {
-        let mut v = Vec::new();
-        for i in inputs {
-            v.push(i.get());
-        }
-
-        let err_val = af_eval_multiple(v.len() as c_int, v.as_ptr() as *const af_array);
-        HANDLE_ERROR(AfError::from(err_val));
+    let mut v = Vec::new();
+    for i in inputs {
+        unsafe { v.push(i.get()) };
     }
+
+    let err_val = unsafe { af_eval_multiple(v.len() as c_int, v.as_ptr() as *const af_array) };
+    HANDLE_ERROR(AfError::from(err_val));
 }
 
 /// Set eval flag value
@@ -861,10 +840,8 @@ pub fn eval_multiple<T: HasAfEnum>(inputs: Vec<&Array<T>>) {
 ///
 /// - `flag` is a boolean value indicating manual evaluation setting
 pub fn set_manual_eval(flag: bool) {
-    unsafe {
-        let err_val = af_set_manual_eval_flag(flag as c_int);
-        HANDLE_ERROR(AfError::from(err_val));
-    }
+    let err_val = unsafe { af_set_manual_eval_flag(flag as c_int) };
+    HANDLE_ERROR(AfError::from(err_val));
 }
 
 /// Get eval flag value
@@ -876,12 +853,10 @@ pub fn set_manual_eval(flag: bool) {
 ///
 /// A boolean indicating manual evaluation setting.
 pub fn is_eval_manual() -> bool {
-    unsafe {
-        let mut ret_val: i32 = 0;
-        let err_val = af_get_manual_eval_flag(&mut ret_val as *mut c_int);
-        HANDLE_ERROR(AfError::from(err_val));
-        ret_val > 0
-    }
+    let mut ret_val: i32 = 0;
+    let err_val = unsafe { af_get_manual_eval_flag(&mut ret_val as *mut c_int) };
+    HANDLE_ERROR(AfError::from(err_val));
+    ret_val > 0
 }
 
 /// Prints data type, shape and data of a given Array in programming friendly context
diff --git a/src/core/backend.rs b/src/core/backend.rs
index d6355d493..2cc3749f4 100644
--- a/src/core/backend.rs
+++ b/src/core/backend.rs
@@ -16,56 +16,48 @@ extern "C" {
 ///
 /// - `backend` to which to switch to
 pub fn set_backend(backend: Backend) {
-    unsafe {
-        let err_val = af_set_backend(backend as u8);
-        HANDLE_ERROR(AfError::from(err_val));
-    }
+    let err_val = unsafe { af_set_backend(backend as u8) };
+    HANDLE_ERROR(AfError::from(err_val));
 }
 
 /// Get the available backend count
 pub fn get_backend_count() -> u32 {
-    unsafe {
-        let mut temp: u32 = 0;
-        let err_val = af_get_backend_count(&mut temp as *mut c_uint);
-        HANDLE_ERROR(AfError::from(err_val));
-        temp
-    }
+    let mut temp: u32 = 0;
+    let err_val = unsafe { af_get_backend_count(&mut temp as *mut c_uint) };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp
 }
 
 /// Get the available backends
 pub fn get_available_backends() -> Vec<Backend> {
-    unsafe {
-        let mut temp: i32 = 0;
-        let err_val = af_get_available_backends(&mut temp as *mut c_int);
-        HANDLE_ERROR(AfError::from(err_val));
-
-        let mut b = Vec::new();
-        if temp & 0b0100 == 0b0100 {
-            b.push(Backend::OPENCL);
-        }
-        if temp & 0b0010 == 0b0010 {
-            b.push(Backend::CUDA);
-        }
-        if temp & 0b0001 == 0b0001 {
-            b.push(Backend::CPU);
-        }
+    let mut temp: i32 = 0;
+    let err_val = unsafe { af_get_available_backends(&mut temp as *mut c_int) };
+    HANDLE_ERROR(AfError::from(err_val));
 
-        b
+    let mut b = Vec::new();
+    if temp & 0b0100 == 0b0100 {
+        b.push(Backend::OPENCL);
     }
+    if temp & 0b0010 == 0b0010 {
+        b.push(Backend::CUDA);
+    }
+    if temp & 0b0001 == 0b0001 {
+        b.push(Backend::CPU);
+    }
+
+    b
 }
 
 /// Get current active backend
 pub fn get_active_backend() -> Backend {
-    unsafe {
-        let mut temp: i32 = 0;
-        let err_val = af_get_active_backend(&mut temp as *mut c_int);
-        HANDLE_ERROR(AfError::from(err_val));
-        match (err_val, temp) {
-            (0, 0) => Backend::DEFAULT,
-            (0, 1) => Backend::CPU,
-            (0, 2) => Backend::CUDA,
-            (0, 4) => Backend::OPENCL,
-            _ => panic!("Invalid backend retrieved, undefined behavior."),
-        }
+    let mut temp: i32 = 0;
+    let err_val = unsafe { af_get_active_backend(&mut temp as *mut c_int) };
+    HANDLE_ERROR(AfError::from(err_val));
+    match (err_val, temp) {
+        (0, 0) => Backend::DEFAULT,
+        (0, 1) => Backend::CPU,
+        (0, 2) => Backend::CUDA,
+        (0, 4) => Backend::OPENCL,
+        _ => panic!("Invalid backend retrieved, undefined behavior."),
     }
 }
diff --git a/src/core/data.rs b/src/core/data.rs
index fe84720f4..62630f58e 100644
--- a/src/core/data.rs
+++ b/src/core/data.rs
@@ -140,17 +140,17 @@ impl ConstGenerator for i64 {
     type OutType = i64;
 
     fn generate(&self, dims: Dim4) -> Array<Self::OutType> {
-        unsafe {
-            let mut temp: af_array = std::ptr::null_mut();
-            let err_val = af_constant_long(
+        let mut temp: af_array = std::ptr::null_mut();
+        let err_val = unsafe {
+            af_constant_long(
                 &mut temp as *mut af_array,
                 *self,
                 dims.ndims() as c_uint,
                 dims.get().as_ptr() as *const dim_t,
-            );
-            HANDLE_ERROR(AfError::from(err_val));
-            temp.into()
-        }
+            )
+        };
+        HANDLE_ERROR(AfError::from(err_val));
+        temp.into()
     }
 }
 
@@ -158,17 +158,17 @@ impl ConstGenerator for u64 {
     type OutType = u64;
 
     fn generate(&self, dims: Dim4) -> Array<Self::OutType> {
-        unsafe {
-            let mut temp: af_array = std::ptr::null_mut();
-            let err_val = af_constant_ulong(
+        let mut temp: af_array = std::ptr::null_mut();
+        let err_val = unsafe {
+            af_constant_ulong(
                 &mut temp as *mut af_array,
                 *self,
                 dims.ndims() as c_uint,
                 dims.get().as_ptr() as *const dim_t,
-            );
-            HANDLE_ERROR(AfError::from(err_val));
-            temp.into()
-        }
+            )
+        };
+        HANDLE_ERROR(AfError::from(err_val));
+        temp.into()
     }
 }
 
@@ -176,19 +176,19 @@ impl ConstGenerator for c32 {
     type OutType = c32;
 
     fn generate(&self, dims: Dim4) -> Array<Self::OutType> {
-        unsafe {
-            let mut temp: af_array = std::ptr::null_mut();
-            let err_val = af_constant_complex(
+        let mut temp: af_array = std::ptr::null_mut();
+        let err_val = unsafe {
+            af_constant_complex(
                 &mut temp as *mut af_array,
                 (*self).re as c_double,
                 (*self).im as c_double,
                 dims.ndims() as c_uint,
                 dims.get().as_ptr() as *const dim_t,
                 1,
-            );
-            HANDLE_ERROR(AfError::from(err_val));
-            temp.into()
-        }
+            )
+        };
+        HANDLE_ERROR(AfError::from(err_val));
+        temp.into()
     }
 }
 
@@ -196,19 +196,19 @@ impl ConstGenerator for c64 {
     type OutType = c64;
 
     fn generate(&self, dims: Dim4) -> Array<Self::OutType> {
-        unsafe {
-            let mut temp: af_array = std::ptr::null_mut();
-            let err_val = af_constant_complex(
+        let mut temp: af_array = std::ptr::null_mut();
+        let err_val = unsafe {
+            af_constant_complex(
                 &mut temp as *mut af_array,
                 (*self).re as c_double,
                 (*self).im as c_double,
                 dims.ndims() as c_uint,
                 dims.get().as_ptr() as *const dim_t,
                 3,
-            );
-            HANDLE_ERROR(AfError::from(err_val));
-            temp.into()
-        }
+            )
+        };
+        HANDLE_ERROR(AfError::from(err_val));
+        temp.into()
     }
 }
 
@@ -216,18 +216,18 @@ impl ConstGenerator for bool {
     type OutType = bool;
 
     fn generate(&self, dims: Dim4) -> Array<Self::OutType> {
-        unsafe {
-            let mut temp: af_array = std::ptr::null_mut();
-            let err_val = af_constant(
+        let mut temp: af_array = std::ptr::null_mut();
+        let err_val = unsafe {
+            af_constant(
                 &mut temp as *mut af_array,
                 *self as c_int as c_double,
                 dims.ndims() as c_uint,
                 dims.get().as_ptr() as *const dim_t,
                 4,
-            );
-            HANDLE_ERROR(AfError::from(err_val));
-            temp.into()
-        }
+            )
+        };
+        HANDLE_ERROR(AfError::from(err_val));
+        temp.into()
     }
 }
 
@@ -237,18 +237,18 @@ macro_rules! cnst {
             type OutType = $rust_type;
 
             fn generate(&self, dims: Dim4) -> Array<Self::OutType> {
-                unsafe {
-                    let mut temp: af_array = std::ptr::null_mut();
-                    let err_val = af_constant(
+                let mut temp: af_array = std::ptr::null_mut();
+                let err_val = unsafe {
+                    af_constant(
                         &mut temp as *mut af_array,
                         *self as c_double,
                         dims.ndims() as c_uint,
                         dims.get().as_ptr() as *const dim_t,
                         $ffi_type,
-                    );
-                    HANDLE_ERROR(AfError::from(err_val));
-                    temp.into()
-                }
+                    )
+                };
+                HANDLE_ERROR(AfError::from(err_val));
+                temp.into()
             }
         }
     };
@@ -307,18 +307,19 @@ where
 /// Array
 pub fn range<T: HasAfEnum>(dims: Dim4, seq_dim: i32) -> Array<T> {
     let aftype = T::get_af_dtype();
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_range(
+
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_range(
             &mut temp as *mut af_array,
             dims.ndims() as c_uint,
             dims.get().as_ptr() as *const dim_t,
             seq_dim as c_int,
             aftype as c_uint,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Create a range of values
@@ -335,19 +336,20 @@ pub fn range<T: HasAfEnum>(dims: Dim4, seq_dim: i32) -> Array<T> {
 /// Array
 pub fn iota<T: HasAfEnum>(dims: Dim4, tdims: Dim4) -> Array<T> {
     let aftype = T::get_af_dtype();
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_iota(
+
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_iota(
             &mut temp as *mut af_array,
             dims.ndims() as c_uint,
             dims.get().as_ptr() as *const dim_t,
             tdims.ndims() as c_uint,
             tdims.get().as_ptr() as *const dim_t,
             aftype as c_uint,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Create an identity array with 1's in diagonal
@@ -361,17 +363,18 @@ pub fn iota<T: HasAfEnum>(dims: Dim4, tdims: Dim4) -> Array<T> {
 /// Identity matrix
 pub fn identity<T: HasAfEnum>(dims: Dim4) -> Array<T> {
     let aftype = T::get_af_dtype();
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_identity(
+
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_identity(
             &mut temp as *mut af_array,
             dims.ndims() as c_uint,
             dims.get().as_ptr() as *const dim_t,
             aftype as c_uint,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Create a diagonal matrix
@@ -389,12 +392,10 @@ pub fn diag_create<T>(input: &Array<T>, dim: i32) -> Array<T>
 where
     T: HasAfEnum,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_diag_create(&mut temp as *mut af_array, input.get(), dim);
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe { af_diag_create(&mut temp as *mut af_array, input.get(), dim) };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Extract diagonal from a given Matrix
@@ -411,12 +412,10 @@ pub fn diag_extract<T>(input: &Array<T>, dim: i32) -> Array<T>
 where
     T: HasAfEnum,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_diag_extract(&mut temp as *mut af_array, input.get(), dim);
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe { af_diag_extract(&mut temp as *mut af_array, input.get(), dim) };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Join two arrays
@@ -434,12 +433,10 @@ pub fn join<T>(dim: i32, first: &Array<T>, second: &Array<T>) -> Array<T>
 where
     T: HasAfEnum,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_join(&mut temp as *mut af_array, dim, first.get(), second.get());
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe { af_join(&mut temp as *mut af_array, dim, first.get(), second.get()) };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Join multiple arrays
@@ -456,21 +453,21 @@ pub fn join_many<T>(dim: i32, inputs: Vec<&Array<T>>) -> Array<T>
 where
     T: HasAfEnum,
 {
-    unsafe {
-        let mut v = Vec::new();
-        for i in inputs {
-            v.push(i.get());
-        }
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_join_many(
+    let mut v = Vec::new();
+    for i in inputs {
+        v.push(unsafe { i.get() });
+    }
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_join_many(
             &mut temp as *mut af_array,
             dim,
             v.len() as u32,
             v.as_ptr() as *const af_array,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Tile the input array along specified dimension
@@ -491,19 +488,19 @@ pub fn tile<T>(input: &Array<T>, dims: Dim4) -> Array<T>
 where
     T: HasAfEnum,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_tile(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_tile(
             &mut temp as *mut af_array,
             input.get() as af_array,
             dims[0] as c_uint,
             dims[1] as c_uint,
             dims[2] as c_uint,
             dims[3] as c_uint,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Reorder the array according to the new specified axes
@@ -587,19 +584,19 @@ where
         }
     };
 
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_reorder(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_reorder(
             &mut temp as *mut af_array,
             input.get() as af_array,
             new_axes[0] as c_uint,
             new_axes[1] as c_uint,
             new_axes[2] as c_uint,
             new_axes[3] as c_uint,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Reorder the array in specified order
@@ -650,19 +647,19 @@ pub fn shift<T>(input: &Array<T>, offsets: &[i32; 4]) -> Array<T>
 where
     T: HasAfEnum,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_shift(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_shift(
             &mut temp as *mut af_array,
             input.get(),
             offsets[0],
             offsets[1],
             offsets[2],
             offsets[3],
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Change the shape of the Array
@@ -678,17 +675,17 @@ pub fn moddims<T>(input: &Array<T>, dims: Dim4) -> Array<T>
 where
     T: HasAfEnum,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_moddims(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_moddims(
             &mut temp as *mut af_array,
             input.get(),
             dims.ndims() as c_uint,
             dims.get().as_ptr() as *const dim_t,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Flatten the multidimensional Array to an 1D Array
@@ -696,12 +693,10 @@ pub fn flat<T>(input: &Array<T>) -> Array<T>
 where
     T: HasAfEnum,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_flat(&mut temp as *mut af_array, input.get());
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe { af_flat(&mut temp as *mut af_array, input.get()) };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Flip the Array
@@ -718,12 +713,10 @@ pub fn flip<T>(input: &Array<T>, dim: u32) -> Array<T>
 where
     T: HasAfEnum,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_flip(&mut temp as *mut af_array, input.get(), dim);
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe { af_flip(&mut temp as *mut af_array, input.get(), dim) };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Create lower triangular matrix
@@ -739,12 +732,10 @@ pub fn lower<T>(input: &Array<T>, is_unit_diag: bool) -> Array<T>
 where
     T: HasAfEnum,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_lower(&mut temp as *mut af_array, input.get(), is_unit_diag);
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe { af_lower(&mut temp as *mut af_array, input.get(), is_unit_diag) };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Create upper triangular matrix
@@ -760,12 +751,10 @@ pub fn upper<T>(input: &Array<T>, is_unit_diag: bool) -> Array<T>
 where
     T: HasAfEnum,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_upper(&mut temp as *mut af_array, input.get(), is_unit_diag);
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe { af_upper(&mut temp as *mut af_array, input.get(), is_unit_diag) };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Element wise conditional operator for Arrays
@@ -792,12 +781,10 @@ pub fn select<T>(a: &Array<T>, cond: &Array<bool>, b: &Array<T>) -> Array<T>
 where
     T: HasAfEnum,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_select(&mut temp as *mut af_array, cond.get(), a.get(), b.get());
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe { af_select(&mut temp as *mut af_array, cond.get(), a.get(), b.get()) };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Element wise conditional operator for Arrays
@@ -824,12 +811,10 @@ pub fn selectl<T>(a: f64, cond: &Array<bool>, b: &Array<T>) -> Array<T>
 where
     T: HasAfEnum,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_select_scalar_l(&mut temp as *mut af_array, cond.get(), a, b.get());
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe { af_select_scalar_l(&mut temp as *mut af_array, cond.get(), a, b.get()) };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Element wise conditional operator for Arrays
@@ -856,12 +841,10 @@ pub fn selectr<T>(a: &Array<T>, cond: &Array<bool>, b: f64) -> Array<T>
 where
     T: HasAfEnum,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_select_scalar_r(&mut temp as *mut af_array, cond.get(), a.get(), b);
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe { af_select_scalar_r(&mut temp as *mut af_array, cond.get(), a.get(), b) };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Inplace replace in Array based on a condition
@@ -887,10 +870,8 @@ pub fn replace<T>(a: &mut Array<T>, cond: &Array<bool>, b: &Array<T>)
 where
     T: HasAfEnum,
 {
-    unsafe {
-        let err_val = af_replace(a.get() as *mut af_array, cond.get(), b.get());
-        HANDLE_ERROR(AfError::from(err_val));
-    }
+    let err_val = unsafe { af_replace(a.get() as *mut af_array, cond.get(), b.get()) };
+    HANDLE_ERROR(AfError::from(err_val));
 }
 
 /// Inplace replace in Array based on a condition
@@ -916,10 +897,8 @@ pub fn replace_scalar<T>(a: &mut Array<T>, cond: &Array<bool>, b: f64)
 where
     T: HasAfEnum,
 {
-    unsafe {
-        let err_val = af_replace_scalar(a.get() as *mut af_array, cond.get(), b);
-        HANDLE_ERROR(AfError::from(err_val));
-    }
+    let err_val = unsafe { af_replace_scalar(a.get() as *mut af_array, cond.get(), b) };
+    HANDLE_ERROR(AfError::from(err_val));
 }
 
 /// Pad input Array along borders
@@ -940,9 +919,9 @@ pub fn pad<T: HasAfEnum>(
     end: Dim4,
     fill_type: BorderType,
 ) -> Array<T> {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_pad(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_pad(
             &mut temp as *mut af_array,
             input.get(),
             4,
@@ -950,10 +929,10 @@ pub fn pad<T: HasAfEnum>(
             4,
             end.get().as_ptr() as *const dim_t,
             fill_type as c_uint,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 #[cfg(test)]
diff --git a/src/core/device.rs b/src/core/device.rs
index f5dc1db61..cd4555a39 100644
--- a/src/core/device.rs
+++ b/src/core/device.rs
@@ -44,18 +44,18 @@ extern "C" {
 /// # Return Values
 /// A triplet of integers indicating major, minor & fix release version numbers.
 pub fn get_version() -> (i32, i32, i32) {
-    unsafe {
-        let mut maj: i32 = 0;
-        let mut min: i32 = 0;
-        let mut pat: i32 = 0;
-        let err_val = af_get_version(
+    let mut maj: i32 = 0;
+    let mut min: i32 = 0;
+    let mut pat: i32 = 0;
+    let err_val = unsafe {
+        af_get_version(
             &mut maj as *mut c_int,
             &mut min as *mut c_int,
             &mut pat as *mut c_int,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        (maj, min, pat)
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    (maj, min, pat)
 }
 
 /// Get ArrayFire Revision (commit) information of the library.
@@ -78,10 +78,8 @@ pub fn get_revision() -> Cow<'static, str> {
 /// [0] GeForce GT 750M, 2048 MB, CUDA Compute 3.0
 /// ```
 pub fn info() {
-    unsafe {
-        let err_val = af_info();
-        HANDLE_ERROR(AfError::from(err_val));
-    }
+    let err_val = unsafe { af_info() };
+    HANDLE_ERROR(AfError::from(err_val));
 }
 
 /// Return library meta-info as `String`
@@ -97,13 +95,13 @@ pub fn info() {
 /// ```
 pub fn info_string(verbose: bool) -> String {
     let result: String;
-    unsafe {
-        let mut tmp: *mut c_char = ::std::ptr::null_mut();
-        let err_val = af_info_string(&mut tmp, verbose);
-        HANDLE_ERROR(AfError::from(err_val));
-        result = CStr::from_ptr(tmp).to_string_lossy().into_owned();
-        free_host(tmp);
-    }
+
+    let mut tmp: *mut c_char = ::std::ptr::null_mut();
+    let err_val = unsafe { af_info_string(&mut tmp, verbose) };
+    HANDLE_ERROR(AfError::from(err_val));
+    result = unsafe { CStr::from_ptr(tmp).to_string_lossy().into_owned() };
+    free_host(tmp);
+
     result
 }
 
@@ -146,20 +144,16 @@ pub fn device_info() -> (String, String, String, String) {
 /// 0th device will be the default device unless init call
 /// is followed by set_device
 pub fn init() {
-    unsafe {
-        let err_val = af_init();
-        HANDLE_ERROR(AfError::from(err_val));
-    }
+    let err_val = unsafe { af_init() };
+    HANDLE_ERROR(AfError::from(err_val));
 }
 
 /// Get total number of available devices
 pub fn device_count() -> i32 {
-    unsafe {
-        let mut temp: i32 = 0;
-        let err_val = af_get_device_count(&mut temp as *mut c_int);
-        HANDLE_ERROR(AfError::from(err_val));
-        temp
-    }
+    let mut temp: i32 = 0;
+    let err_val = unsafe { af_get_device_count(&mut temp as *mut c_int) };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp
 }
 
 /// Check if a device has double support
@@ -172,12 +166,10 @@ pub fn device_count() -> i32 {
 ///
 /// `True` if `device` device has double support, `False` otherwise.
 pub fn is_double_available(device: i32) -> bool {
-    unsafe {
-        let mut temp: i32 = 0;
-        let err_val = af_get_dbl_support(&mut temp as *mut c_int, device as c_int);
-        HANDLE_ERROR(AfError::from(err_val));
-        temp > 0
-    }
+    let mut temp: i32 = 0;
+    let err_val = unsafe { af_get_dbl_support(&mut temp as *mut c_int, device as c_int) };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp > 0
 }
 
 /// Set active device
@@ -186,20 +178,16 @@ pub fn is_double_available(device: i32) -> bool {
 ///
 /// - `device` is the value of the device identifier which has to be set as active
 pub fn set_device(device: i32) {
-    unsafe {
-        let err_val = af_set_device(device as c_int);
-        HANDLE_ERROR(AfError::from(err_val));
-    }
+    let err_val = unsafe { af_set_device(device as c_int) };
+    HANDLE_ERROR(AfError::from(err_val));
 }
 
 /// Get the current active device id
 pub fn get_device() -> i32 {
-    unsafe {
-        let mut temp: i32 = 0;
-        let err_val = af_get_device(&mut temp as *mut c_int);
-        HANDLE_ERROR(AfError::from(err_val));
-        temp
-    }
+    let mut temp: i32 = 0;
+    let err_val = unsafe { af_get_device(&mut temp as *mut c_int) };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp
 }
 
 /// Get memory information from the memory manager for the current active device
@@ -217,20 +205,20 @@ pub fn get_device() -> i32 {
 /// * Number of bytes locked
 /// * Number of buffers locked
 pub fn device_mem_info() -> (usize, usize, usize, usize) {
-    unsafe {
-        let mut o0: usize = 0;
-        let mut o1: usize = 0;
-        let mut o2: usize = 0;
-        let mut o3: usize = 0;
-        let err_val = af_device_mem_info(
+    let mut o0: usize = 0;
+    let mut o1: usize = 0;
+    let mut o2: usize = 0;
+    let mut o3: usize = 0;
+    let err_val = unsafe {
+        af_device_mem_info(
             &mut o0 as *mut size_t,
             &mut o1 as *mut size_t,
             &mut o2 as *mut size_t,
             &mut o3 as *mut size_t,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        (o0, o1, o2, o3)
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    (o0, o1, o2, o3)
 }
 
 /// Print buffer details from the ArrayFire device manager
@@ -246,18 +234,18 @@ pub fn device_mem_info() -> (usize, usize, usize, usize) {
 ///
 /// None
 pub fn print_mem_info(msg: String, device: i32) {
-    unsafe {
-        let cmsg = CString::new(msg.as_bytes());
-        match cmsg {
-            Ok(v) => {
-                let err_val = af_print_mem_info(
+    let cmsg = CString::new(msg.as_bytes());
+    match cmsg {
+        Ok(v) => {
+            let err_val = unsafe {
+                af_print_mem_info(
                     v.to_bytes_with_nul().as_ptr() as *const c_char,
                     device as c_int,
-                );
-                HANDLE_ERROR(AfError::from(err_val));
-            }
-            Err(_) => HANDLE_ERROR(AfError::ERR_INTERNAL),
+                )
+            };
+            HANDLE_ERROR(AfError::from(err_val));
         }
+        Err(_) => HANDLE_ERROR(AfError::ERR_INTERNAL),
     }
 }
 
@@ -271,10 +259,8 @@ pub fn print_mem_info(msg: String, device: i32) {
 ///
 /// None
 pub fn set_mem_step_size(step_bytes: usize) {
-    unsafe {
-        let err_val = af_set_mem_step_size(step_bytes as size_t);
-        HANDLE_ERROR(AfError::from(err_val));
-    }
+    let err_val = unsafe { af_set_mem_step_size(step_bytes as size_t) };
+    HANDLE_ERROR(AfError::from(err_val));
 }
 
 /// Get the minimum memory chunk size
@@ -287,20 +273,16 @@ pub fn set_mem_step_size(step_bytes: usize) {
 ///
 /// Returns is the size of minimum memory chunk in bytes
 pub fn get_mem_step_size() -> usize {
-    unsafe {
-        let mut temp: usize = 0;
-        let err_val = af_get_mem_step_size(&mut temp as *mut size_t);
-        HANDLE_ERROR(AfError::from(err_val));
-        temp
-    }
+    let mut temp: usize = 0;
+    let err_val = unsafe { af_get_mem_step_size(&mut temp as *mut size_t) };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp
 }
 
 /// Call the garbage collection routine
 pub fn device_gc() {
-    unsafe {
-        let err_val = af_device_gc();
-        HANDLE_ERROR(AfError::from(err_val));
-    }
+    let err_val = unsafe { af_device_gc() };
+    HANDLE_ERROR(AfError::from(err_val));
 }
 
 /// Sync all operations on given device
@@ -313,10 +295,8 @@ pub fn device_gc() {
 ///
 /// None
 pub fn sync(device: i32) {
-    unsafe {
-        let err_val = af_sync(device as c_int);
-        HANDLE_ERROR(AfError::from(err_val));
-    }
+    let err_val = unsafe { af_sync(device as c_int) };
+    HANDLE_ERROR(AfError::from(err_val));
 }
 
 /// Allocate non-pageable memory on HOST memory
@@ -355,10 +335,8 @@ pub unsafe fn free_pinned(ptr: void_ptr) {
 ///
 /// `True` if `device` device has half support, `False` otherwise.
 pub fn is_half_available(device: i32) -> bool {
-    unsafe {
-        let mut temp: i32 = 0;
-        let err_val = af_get_half_support(&mut temp as *mut c_int, device as c_int);
-        HANDLE_ERROR(AfError::from(err_val));
-        temp > 0
-    }
+    let mut temp: i32 = 0;
+    let err_val = unsafe { af_get_half_support(&mut temp as *mut c_int, device as c_int) };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp > 0
 }
diff --git a/src/core/event.rs b/src/core/event.rs
index cb589a14b..674858c1c 100644
--- a/src/core/event.rs
+++ b/src/core/event.rs
@@ -28,10 +28,10 @@ unsafe impl Send for Event {}
 impl Default for Event {
     fn default() -> Self {
         let mut temp: af_event = std::ptr::null_mut();
-        unsafe {
-            let err_val = af_create_event(&mut temp as *mut af_event);
-            HANDLE_ERROR(AfError::from(err_val));
-        }
+
+        let err_val = unsafe { af_create_event(&mut temp as *mut af_event) };
+        HANDLE_ERROR(AfError::from(err_val));
+
         Self { event_handle: temp }
     }
 }
@@ -43,10 +43,8 @@ impl Event {
     /// enqueued on the event queue will be completed before any events that are
     /// enqueued after the call to enqueue
     pub fn mark(&self) {
-        unsafe {
-            let err_val = af_mark_event(self.event_handle as af_event);
-            HANDLE_ERROR(AfError::from(err_val));
-        }
+        let err_val = unsafe { af_mark_event(self.event_handle as af_event) };
+        HANDLE_ERROR(AfError::from(err_val));
     }
 
     /// Enqueues the event and all enqueued events on the active queue
@@ -54,10 +52,8 @@ impl Event {
     /// All operations enqueued after a call to enqueue will not be executed
     /// until operations on the queue when mark was called are complete
     pub fn enqueue_wait(&self) {
-        unsafe {
-            let err_val = af_enqueue_wait_event(self.event_handle as af_event);
-            HANDLE_ERROR(AfError::from(err_val));
-        }
+        let err_val = unsafe { af_enqueue_wait_event(self.event_handle as af_event) };
+        HANDLE_ERROR(AfError::from(err_val));
     }
 
     /// Blocks the calling thread on events until all events on the computation
@@ -72,12 +68,10 @@ impl Event {
 
 impl Drop for Event {
     fn drop(&mut self) {
-        unsafe {
-            let ret_val = af_delete_event(self.event_handle as af_event);
-            match ret_val {
-                0 => (),
-                _ => panic!("Failed to delete event resources: {}", ret_val),
-            }
+        let ret_val = unsafe { af_delete_event(self.event_handle as af_event) };
+        match ret_val {
+            0 => (),
+            _ => panic!("Failed to delete event resources: {}", ret_val),
         }
     }
 }
diff --git a/src/core/index.rs b/src/core/index.rs
index d87f0c1af..b4a1b2a2b 100644
--- a/src/core/index.rs
+++ b/src/core/index.rs
@@ -147,10 +147,8 @@ where
     T: HasAfEnum + IndexableType,
 {
     fn set(&self, idxr: &mut Indexer, dim: u32, _is_batch: Option<bool>) {
-        unsafe {
-            let err_val = af_set_array_indexer(idxr.get(), self.get(), dim as dim_t);
-            HANDLE_ERROR(AfError::from(err_val));
-        }
+        let err_val = unsafe { af_set_array_indexer(idxr.get(), self.get(), dim as dim_t) };
+        HANDLE_ERROR(AfError::from(err_val));
     }
 }
 
@@ -164,29 +162,27 @@ where
     T: Copy + IndexableType,
 {
     fn set(&self, idxr: &mut Indexer, dim: u32, is_batch: Option<bool>) {
-        unsafe {
-            let err_val = af_set_seq_indexer(
+        let err_val = unsafe {
+            af_set_seq_indexer(
                 idxr.get(),
                 &SeqInternal::from_seq(self) as *const SeqInternal,
                 dim as dim_t,
                 is_batch.unwrap_or(false),
-            );
-            HANDLE_ERROR(AfError::from(err_val));
-        }
+            )
+        };
+        HANDLE_ERROR(AfError::from(err_val));
     }
 }
 
 impl<'object> Default for Indexer<'object> {
     fn default() -> Self {
-        unsafe {
-            let mut temp: af_index_t = std::ptr::null_mut();
-            let err_val = af_create_indexers(&mut temp as *mut af_index_t);
-            HANDLE_ERROR(AfError::from(err_val));
-            Self {
-                handle: temp,
-                count: 0,
-                marker: PhantomData,
-            }
+        let mut temp: af_index_t = std::ptr::null_mut();
+        let err_val = unsafe { af_create_indexers(&mut temp as *mut af_index_t) };
+        HANDLE_ERROR(AfError::from(err_val));
+        Self {
+            handle: temp,
+            count: 0,
+            marker: PhantomData,
         }
     }
 }
@@ -195,15 +191,13 @@ impl<'object> Indexer<'object> {
     /// Create a new Indexer object and set the dimension specific index objects later
     #[deprecated(since = "3.7.0", note = "Use Indexer::default() instead")]
     pub fn new() -> Self {
-        unsafe {
-            let mut temp: af_index_t = std::ptr::null_mut();
-            let err_val = af_create_indexers(&mut temp as *mut af_index_t);
-            HANDLE_ERROR(AfError::from(err_val));
-            Self {
-                handle: temp,
-                count: 0,
-                marker: PhantomData,
-            }
+        let mut temp: af_index_t = std::ptr::null_mut();
+        let err_val = unsafe { af_create_indexers(&mut temp as *mut af_index_t) };
+        HANDLE_ERROR(AfError::from(err_val));
+        Self {
+            handle: temp,
+            count: 0,
+            marker: PhantomData,
         }
     }
 
@@ -234,12 +228,10 @@ impl<'object> Indexer<'object> {
 
 impl<'object> Drop for Indexer<'object> {
     fn drop(&mut self) {
-        unsafe {
-            let ret_val = af_release_indexers(self.handle as af_index_t);
-            match ret_val {
-                0 => (),
-                _ => panic!("Failed to release indexers resource: {}", ret_val),
-            }
+        let ret_val = unsafe { af_release_indexers(self.handle as af_index_t) };
+        match ret_val {
+            0 => (),
+            _ => panic!("Failed to release indexers resource: {}", ret_val),
         }
     }
 }
@@ -264,17 +256,18 @@ where
     T: Copy + HasAfEnum + IndexableType,
 {
     let seqs: Vec<SeqInternal> = seqs.iter().map(|s| SeqInternal::from_seq(s)).collect();
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_index(
+
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_index(
             &mut temp as *mut af_array,
             input.get(),
             seqs.len() as u32,
             seqs.as_ptr() as *const SeqInternal,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Extract `row_num` row from `input` Array
@@ -488,17 +481,17 @@ where
     T: HasAfEnum,
     I: HasAfEnum + IndexableType,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_lookup(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_lookup(
             &mut temp as *mut af_array,
             input.get() as af_array,
             indices.get() as af_array,
             seq_dim as c_uint,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Assign(copy) content of an Array to another Array indexed by Sequences
@@ -535,20 +528,21 @@ where
     T: Copy + IndexableType,
 {
     let seqs: Vec<SeqInternal> = seqs.iter().map(|s| SeqInternal::from_seq(s)).collect();
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_assign_seq(
+
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_assign_seq(
             &mut temp as *mut af_array,
             lhs.get() as af_array,
             seqs.len() as c_uint,
             seqs.as_ptr() as *const SeqInternal,
             rhs.get() as af_array,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
 
-        let modified = temp.into();
-        let _old_arr = mem::replace(lhs, modified);
-    }
+    let modified = temp.into();
+    let _old_arr = mem::replace(lhs, modified);
 }
 
 /// Index an Array using any combination of Array's and Sequence's
@@ -584,17 +578,17 @@ pub fn index_gen<T>(input: &Array<T>, indices: Indexer) -> Array<T>
 where
     T: HasAfEnum,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_index_gen(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_index_gen(
             &mut temp as *mut af_array,
             input.get() as af_array,
             indices.len() as dim_t,
             indices.get() as af_index_t,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Assign an Array to another after indexing it using any combination of Array's and Sequence's
@@ -633,20 +627,20 @@ pub fn assign_gen<T>(lhs: &mut Array<T>, indices: &Indexer, rhs: &Array<T>)
 where
     T: HasAfEnum,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_assign_gen(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_assign_gen(
             &mut temp as *mut af_array,
             lhs.get() as af_array,
             indices.len() as dim_t,
             indices.get() as af_index_t,
             rhs.get() as af_array,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
 
-        let modified = temp.into();
-        let _old_arr = mem::replace(lhs, modified);
-    }
+    let modified = temp.into();
+    let _old_arr = mem::replace(lhs, modified);
 }
 
 #[repr(C)]
diff --git a/src/core/random.rs b/src/core/random.rs
index 77c86f7c0..f05dd6063 100644
--- a/src/core/random.rs
+++ b/src/core/random.rs
@@ -45,19 +45,17 @@ extern "C" {
 
 /// Set seed for random number generation
 pub fn set_seed(seed: u64) {
-    unsafe {
-        let err_val = af_set_seed(seed as u64_t);
-        HANDLE_ERROR(AfError::from(err_val));
-    }
+    let err_val = unsafe { af_set_seed(seed as u64_t) };
+    HANDLE_ERROR(AfError::from(err_val));
 }
 
 /// Get the seed of random number generator
 pub fn get_seed() -> u64 {
     let mut ret_val: u64 = 0;
-    unsafe {
-        let err_val = af_get_seed(&mut ret_val as *mut u64_t);
-        HANDLE_ERROR(AfError::from(err_val));
-    }
+
+    let err_val = unsafe { af_get_seed(&mut ret_val as *mut u64_t) };
+    HANDLE_ERROR(AfError::from(err_val));
+
     ret_val
 }
 
@@ -138,55 +136,54 @@ impl RandomEngine {
     ///
     /// A object of type RandomEngine
     pub fn new(rengine: RandomEngineType, seed: Option<u64>) -> Self {
-        unsafe {
-            let mut temp: af_random_engine = std::ptr::null_mut();
-            let err_val = af_create_random_engine(
+        let mut temp: af_random_engine = std::ptr::null_mut();
+        let err_val = unsafe {
+            af_create_random_engine(
                 &mut temp as *mut af_random_engine,
                 rengine as c_uint,
                 seed.unwrap_or(0u64),
-            );
-            HANDLE_ERROR(AfError::from(err_val));
-            RandomEngine { handle: temp }
-        }
+            )
+        };
+        HANDLE_ERROR(AfError::from(err_val));
+        RandomEngine { handle: temp }
     }
 
     /// Get random engine type
     pub fn get_type(&self) -> RandomEngineType {
         let mut temp: u32 = 0;
-        unsafe {
-            let err_val = af_random_engine_get_type(&mut temp as *mut c_uint, self.handle);
-            HANDLE_ERROR(AfError::from(err_val));
-        }
+
+        let err_val = unsafe { af_random_engine_get_type(&mut temp as *mut c_uint, self.handle) };
+        HANDLE_ERROR(AfError::from(err_val));
+
         RandomEngineType::from(temp)
     }
 
     /// Get random engine type
     pub fn set_type(&mut self, engine_type: RandomEngineType) {
-        unsafe {
-            let err_val = af_random_engine_set_type(
+        let err_val = unsafe {
+            af_random_engine_set_type(
                 &mut self.handle as *mut af_random_engine,
                 engine_type as c_uint,
-            );
-            HANDLE_ERROR(AfError::from(err_val));
-        }
+            )
+        };
+        HANDLE_ERROR(AfError::from(err_val));
     }
 
     /// Set seed for random engine
     pub fn set_seed(&mut self, seed: u64) {
-        unsafe {
-            let err_val =
-                af_random_engine_set_seed(&mut self.handle as *mut af_random_engine, seed as u64_t);
-            HANDLE_ERROR(AfError::from(err_val));
-        }
+        let err_val = unsafe {
+            af_random_engine_set_seed(&mut self.handle as *mut af_random_engine, seed as u64_t)
+        };
+        HANDLE_ERROR(AfError::from(err_val));
     }
 
     /// Get seed of the random engine
     pub fn get_seed(&self) -> u64 {
         let mut seed: u64 = 0;
-        unsafe {
-            let err_val = af_random_engine_get_seed(&mut seed as *mut u64_t, self.handle);
-            HANDLE_ERROR(AfError::from(err_val));
-        }
+
+        let err_val = unsafe { af_random_engine_get_seed(&mut seed as *mut u64_t, self.handle) };
+        HANDLE_ERROR(AfError::from(err_val));
+
         seed
     }
 
@@ -199,22 +196,19 @@ impl RandomEngine {
 /// Increment reference count of RandomEngine's native resource
 impl Clone for RandomEngine {
     fn clone(&self) -> Self {
-        unsafe {
-            let mut temp: af_random_engine = std::ptr::null_mut();
-            let err_val = af_retain_random_engine(&mut temp as *mut af_random_engine, self.handle);
-            HANDLE_ERROR(AfError::from(err_val));
-            RandomEngine::from(temp)
-        }
+        let mut temp: af_random_engine = std::ptr::null_mut();
+        let err_val =
+            unsafe { af_retain_random_engine(&mut temp as *mut af_random_engine, self.handle) };
+        HANDLE_ERROR(AfError::from(err_val));
+        RandomEngine::from(temp)
     }
 }
 
 /// Free RandomEngine's native resource
 impl Drop for RandomEngine {
     fn drop(&mut self) {
-        unsafe {
-            let err_val = af_release_random_engine(self.handle);
-            HANDLE_ERROR(AfError::from(err_val));
-        }
+        let err_val = unsafe { af_release_random_engine(self.handle) };
+        HANDLE_ERROR(AfError::from(err_val));
     }
 }
 
@@ -264,15 +258,13 @@ mod afserde {
 
 /// Get default random engine
 pub fn get_default_random_engine() -> RandomEngine {
-    unsafe {
-        let mut temp: af_random_engine = std::ptr::null_mut();
-        let mut err_val = af_get_default_random_engine(&mut temp as *mut af_random_engine);
-        HANDLE_ERROR(AfError::from(err_val));
-        let mut handle: af_random_engine = std::ptr::null_mut();
-        err_val = af_retain_random_engine(&mut handle as *mut af_random_engine, temp);
-        HANDLE_ERROR(AfError::from(err_val));
-        RandomEngine { handle }
-    }
+    let mut temp: af_random_engine = std::ptr::null_mut();
+    let mut err_val = unsafe { af_get_default_random_engine(&mut temp as *mut af_random_engine) };
+    HANDLE_ERROR(AfError::from(err_val));
+    let mut handle: af_random_engine = std::ptr::null_mut();
+    err_val = unsafe { af_retain_random_engine(&mut handle as *mut af_random_engine, temp) };
+    HANDLE_ERROR(AfError::from(err_val));
+    RandomEngine { handle }
 }
 
 /// Set the random engine type for default random number generator
@@ -281,10 +273,8 @@ pub fn get_default_random_engine() -> RandomEngine {
 ///
 /// - `rtype` can take one of the values of enum [RandomEngineType](./enum.RandomEngineType.html)
 pub fn set_default_random_engine_type(rtype: RandomEngineType) {
-    unsafe {
-        let err_val = af_set_default_random_engine_type(rtype as c_uint);
-        HANDLE_ERROR(AfError::from(err_val));
-    }
+    let err_val = unsafe { af_set_default_random_engine_type(rtype as c_uint) };
+    HANDLE_ERROR(AfError::from(err_val));
 }
 
 /// Generate array of uniform numbers using a random engine
@@ -302,18 +292,19 @@ where
     T: HasAfEnum,
 {
     let aftype = T::get_af_dtype();
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_random_uniform(
+
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_random_uniform(
             &mut temp as *mut af_array,
             dims.ndims() as c_uint,
             dims.get().as_ptr() as *const dim_t,
             aftype as c_uint,
             engine.get(),
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Generate array of normal numbers using a random engine
@@ -331,18 +322,19 @@ where
     T: HasAfEnum + FloatingPoint,
 {
     let aftype = T::get_af_dtype();
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_random_normal(
+
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_random_normal(
             &mut temp as *mut af_array,
             dims.ndims() as c_uint,
             dims.get().as_ptr() as *const dim_t,
             aftype as c_uint,
             engine.get(),
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 #[cfg(test)]
diff --git a/src/core/util.rs b/src/core/util.rs
index b43635820..d5c10f4fd 100644
--- a/src/core/util.rs
+++ b/src/core/util.rs
@@ -43,31 +43,27 @@ extern "C" {
 
 /// Get size, in bytes, of the arrayfire native type
 pub fn get_size(value: DType) -> usize {
-    unsafe {
-        let mut ret_val: usize = 0;
-        let err_val = af_get_size_of(&mut ret_val as *mut size_t, value as c_uint);
-        HANDLE_ERROR(AfError::from(err_val));
-        ret_val
-    }
+    let mut ret_val: usize = 0;
+    let err_val = unsafe { af_get_size_of(&mut ret_val as *mut size_t, value as c_uint) };
+    HANDLE_ERROR(AfError::from(err_val));
+    ret_val
 }
 
 /// Allocates space using Arrayfire allocator in host memory
 pub fn alloc_host<T>(elements: usize, _type: DType) -> *const T {
     let ptr: *const T = ::std::ptr::null();
     let bytes = (elements * get_size(_type)) as dim_t;
-    unsafe {
-        let err_val = af_alloc_host(&mut (ptr as *const c_void), bytes);
-        HANDLE_ERROR(AfError::from(err_val));
-    }
+
+    let err_val = unsafe { af_alloc_host(&mut (ptr as *const c_void), bytes) };
+    HANDLE_ERROR(AfError::from(err_val));
+
     ptr
 }
 
 /// Frees memory allocated by Arrayfire allocator in host memory
 pub fn free_host<T>(ptr: *mut T) {
-    unsafe {
-        let err_val = af_free_host(ptr as *mut c_void);
-        HANDLE_ERROR(AfError::from(err_val));
-    }
+    let err_val = unsafe { af_free_host(ptr as *mut c_void) };
+    HANDLE_ERROR(AfError::from(err_val));
 }
 
 impl From<i32> for AfError {
diff --git a/src/graphics/mod.rs b/src/graphics/mod.rs
index df164a760..64777e7fa 100644
--- a/src/graphics/mod.rs
+++ b/src/graphics/mod.rs
@@ -187,15 +187,13 @@ pub struct Window {
 
 impl Drop for Window {
     fn drop(&mut self) {
-        unsafe {
-            let err_val = af_destroy_window(self.handle);
-            match err_val {
-                0 => (),
-                _ => panic!(
-                    "Window object destruction failed with error code: {}",
-                    err_val
-                ),
-            }
+        let err_val = unsafe { af_destroy_window(self.handle) };
+        match err_val {
+            0 => (),
+            _ => panic!(
+                "Window object destruction failed with error code: {}",
+                err_val
+            ),
         }
     }
 }
@@ -214,25 +212,24 @@ impl Window {
     /// Window Object
     #[allow(clippy::match_wild_err_arm)]
     pub fn new(width: i32, height: i32, title: String) -> Self {
-        unsafe {
-            let cstr_ret = CString::new(title);
-            match cstr_ret {
-                Ok(cstr) => {
-                    let mut temp: af_window = std::ptr::null_mut();
-                    let err_val =
-                        af_create_window(&mut temp as *mut af_window, width, height, cstr.as_ptr());
-                    HANDLE_ERROR(AfError::from(err_val));
-                    Window {
-                        handle: temp,
-                        row: -1,
-                        col: -1,
-                        cmap: ColorMap::DEFAULT,
-                    }
-                }
-                Err(_) => {
-                    panic!("String creation failed while prepping params for window creation.")
+        let cstr_ret = CString::new(title);
+        match cstr_ret {
+            Ok(cstr) => {
+                let mut temp: af_window = std::ptr::null_mut();
+                let err_val = unsafe {
+                    af_create_window(&mut temp as *mut af_window, width, height, cstr.as_ptr())
+                };
+                HANDLE_ERROR(AfError::from(err_val));
+                Window {
+                    handle: temp,
+                    row: -1,
+                    col: -1,
+                    cmap: ColorMap::DEFAULT,
                 }
             }
+            Err(_) => {
+                panic!("String creation failed while prepping params for window creation.")
+            }
         }
     }
 
@@ -243,10 +240,8 @@ impl Window {
     /// - `x` is the horiontal coordinate where window is to be placed
     /// - `y` is the vertical coordinate where window is to be placed
     pub fn set_position(&self, x: u32, y: u32) {
-        unsafe {
-            let err_val = af_set_position(self.handle, x, y);
-            HANDLE_ERROR(AfError::from(err_val));
-        }
+        let err_val = unsafe { af_set_position(self.handle, x, y) };
+        HANDLE_ERROR(AfError::from(err_val));
     }
 
     /// Set window title
@@ -255,15 +250,13 @@ impl Window {
     ///
     /// - `title` is the string to be displayed on window title bar
     pub fn set_title(&self, title: String) {
-        unsafe {
-            let cstr_ret = CString::new(title);
-            match cstr_ret {
-                Ok(cstr) => {
-                    let err_val = af_set_title(self.handle, cstr.as_ptr());
-                    HANDLE_ERROR(AfError::from(err_val));
-                }
-                Err(_) => HANDLE_ERROR(AfError::ERR_INTERNAL),
+        let cstr_ret = CString::new(title);
+        match cstr_ret {
+            Ok(cstr) => {
+                let err_val = unsafe { af_set_title(self.handle, cstr.as_ptr()) };
+                HANDLE_ERROR(AfError::from(err_val));
             }
+            Err(_) => HANDLE_ERROR(AfError::ERR_INTERNAL),
         }
     }
 
@@ -277,10 +270,8 @@ impl Window {
     ///
     /// None
     pub fn set_visibility(&self, is_visible: bool) {
-        unsafe {
-            let err_val = af_set_visibility(self.handle, is_visible);
-            HANDLE_ERROR(AfError::from(err_val));
-        }
+        let err_val = unsafe { af_set_visibility(self.handle, is_visible) };
+        HANDLE_ERROR(AfError::from(err_val));
     }
 
     /// Set window size
@@ -290,10 +281,8 @@ impl Window {
     /// - `w` is the target width of window
     /// - `h` is the target height of window
     pub fn set_size(&self, w: u32, h: u32) {
-        unsafe {
-            let err_val = af_set_size(self.handle, w, h);
-            HANDLE_ERROR(AfError::from(err_val));
-        }
+        let err_val = unsafe { af_set_size(self.handle, w, h) };
+        HANDLE_ERROR(AfError::from(err_val));
     }
 
     /// Set color map to be used for rendering image, it can take one of the values of enum
@@ -304,12 +293,10 @@ impl Window {
 
     /// Returns true if the window close is triggered by the user
     pub fn is_closed(&self) -> bool {
-        unsafe {
-            let mut temp: bool = true;
-            let err_val = af_is_window_closed(&mut temp as *mut bool, self.handle);
-            HANDLE_ERROR(AfError::from(err_val));
-            temp
-        }
+        let mut temp: bool = true;
+        let err_val = unsafe { af_is_window_closed(&mut temp as *mut bool, self.handle) };
+        HANDLE_ERROR(AfError::from(err_val));
+        temp
     }
 
     /// Setup display layout in multiview mode
@@ -319,21 +306,17 @@ impl Window {
     /// - `rows` is the number of rows into which whole window is split into in multiple view mode
     /// - `cols` is the number of cols into which whole window is split into in multiple view mode
     pub fn grid(&self, rows: i32, cols: i32) {
-        unsafe {
-            let err_val = af_grid(self.handle, rows, cols);
-            HANDLE_ERROR(AfError::from(err_val));
-        }
+        let err_val = unsafe { af_grid(self.handle, rows, cols) };
+        HANDLE_ERROR(AfError::from(err_val));
     }
 
     /// Used in multiview mode to swap back buffer with front buffer to show the recently rendered
     /// frame
     pub fn show(&mut self) {
-        unsafe {
-            let err_val = af_show(self.handle);
-            HANDLE_ERROR(AfError::from(err_val));
-            self.row = -1;
-            self.col = -1;
-        }
+        let err_val = unsafe { af_show(self.handle) };
+        HANDLE_ERROR(AfError::from(err_val));
+        self.row = -1;
+        self.col = -1;
     }
 
     /// Set the current sub-region to render
@@ -366,16 +349,17 @@ impl Window {
         let xstr = CString::new(xlabel).unwrap();
         let ystr = CString::new(ylabel).unwrap();
         let zstr = CString::new(zlabel).unwrap();
-        unsafe {
-            let err_val = af_set_axes_titles(
+
+        let err_val = unsafe {
+            af_set_axes_titles(
                 self.handle,
                 xstr.as_ptr(),
                 ystr.as_ptr(),
                 zstr.as_ptr(),
                 &cprops as *const af_cell,
-            );
-            HANDLE_ERROR(AfError::from(err_val));
-        }
+            )
+        };
+        HANDLE_ERROR(AfError::from(err_val));
     }
 
     /// Set chart axes labels format
@@ -400,16 +384,17 @@ impl Window {
         let xstr = CString::new(xlabel_format).unwrap();
         let ystr = CString::new(ylabel_format).unwrap();
         let zstr = CString::new(zlabel_format).unwrap();
-        unsafe {
-            let err_val = af_set_axes_label_format(
+
+        let err_val = unsafe {
+            af_set_axes_label_format(
                 self.handle,
                 xstr.as_ptr(),
                 ystr.as_ptr(),
                 zstr.as_ptr(),
                 &cprops as *const af_cell,
-            );
-            HANDLE_ERROR(AfError::from(err_val));
-        }
+            )
+        };
+        HANDLE_ERROR(AfError::from(err_val));
     }
 
     /// Set chart axes labels formats
@@ -433,16 +418,17 @@ impl Window {
         let xstr = CString::new(xformat).unwrap();
         let ystr = CString::new(yformat).unwrap();
         let zstr = CString::new(zformat).unwrap();
-        unsafe {
-            let err_val = af_set_axes_titles(
+
+        let err_val = unsafe {
+            af_set_axes_titles(
                 self.handle,
                 xstr.as_ptr(),
                 ystr.as_ptr(),
                 zstr.as_ptr(),
                 &cprops as *const af_cell,
-            );
-            HANDLE_ERROR(AfError::from(err_val));
-        }
+            )
+        };
+        HANDLE_ERROR(AfError::from(err_val));
     }
 
     /// Set chart axes limits by computing limits from data
@@ -474,8 +460,9 @@ impl Window {
             title: ptr::null(),
             cmap: self.cmap as u32,
         };
-        unsafe {
-            let err_val = af_set_axes_limits_compute(
+
+        let err_val = unsafe {
+            af_set_axes_limits_compute(
                 self.handle,
                 xrange.get(),
                 yrange.get(),
@@ -485,9 +472,9 @@ impl Window {
                 },
                 exact,
                 &cprops as *const af_cell,
-            );
-            HANDLE_ERROR(AfError::from(err_val));
-        }
+            )
+        };
+        HANDLE_ERROR(AfError::from(err_val));
     }
 
     /// Set 2d chart axes limits
@@ -511,8 +498,9 @@ impl Window {
             title: ptr::null(),
             cmap: self.cmap as u32,
         };
-        unsafe {
-            let err_val = af_set_axes_limits_2d(
+
+        let err_val = unsafe {
+            af_set_axes_limits_2d(
                 self.handle,
                 xmin,
                 xmax,
@@ -520,9 +508,9 @@ impl Window {
                 ymax,
                 exact,
                 &cprops as *const af_cell,
-            );
-            HANDLE_ERROR(AfError::from(err_val));
-        }
+            )
+        };
+        HANDLE_ERROR(AfError::from(err_val));
     }
 
     /// Set 3d chart axes limits
@@ -558,8 +546,9 @@ impl Window {
             title: ptr::null(),
             cmap: self.cmap as u32,
         };
-        unsafe {
-            let err_val = af_set_axes_limits_3d(
+
+        let err_val = unsafe {
+            af_set_axes_limits_3d(
                 self.handle,
                 xmin,
                 xmax,
@@ -569,9 +558,9 @@ impl Window {
                 zmax,
                 exact,
                 &cprops as *const af_cell,
-            );
-            HANDLE_ERROR(AfError::from(err_val));
-        }
+            )
+        };
+        HANDLE_ERROR(AfError::from(err_val));
     }
 
     /// Render given Array as an image
@@ -596,10 +585,9 @@ impl Window {
             title: tstr.as_ptr(),
             cmap: self.cmap as u32,
         };
-        unsafe {
-            let err_val = af_draw_image(self.handle, input.get(), &cprops as *const af_cell);
-            HANDLE_ERROR(AfError::from(err_val));
-        }
+
+        let err_val = unsafe { af_draw_image(self.handle, input.get(), &cprops as *const af_cell) };
+        HANDLE_ERROR(AfError::from(err_val));
     }
 
     /// Render given two Array's `x` and `y` as a 2d line plot
@@ -625,10 +613,10 @@ impl Window {
             title: tstr.as_ptr(),
             cmap: self.cmap as u32,
         };
-        unsafe {
-            let err_val = af_draw_plot_2d(self.handle, x.get(), y.get(), &cprops as *const af_cell);
-            HANDLE_ERROR(AfError::from(err_val));
-        }
+
+        let err_val =
+            unsafe { af_draw_plot_2d(self.handle, x.get(), y.get(), &cprops as *const af_cell) };
+        HANDLE_ERROR(AfError::from(err_val));
     }
 
     /// Render given Array's `x`, `y` and `z` as a 3d line plot
@@ -655,16 +643,17 @@ impl Window {
             title: tstr.as_ptr(),
             cmap: self.cmap as u32,
         };
-        unsafe {
-            let err_val = af_draw_plot_3d(
+
+        let err_val = unsafe {
+            af_draw_plot_3d(
                 self.handle,
                 x.get(),
                 y.get(),
                 z.get(),
                 &cprops as *const af_cell,
-            );
-            HANDLE_ERROR(AfError::from(err_val));
-        }
+            )
+        };
+        HANDLE_ERROR(AfError::from(err_val));
     }
 
     /// Render give Arrays of points as a 3d line plot
@@ -689,10 +678,10 @@ impl Window {
             title: tstr.as_ptr(),
             cmap: self.cmap as u32,
         };
-        unsafe {
-            let err_val = af_draw_plot_nd(self.handle, points.get(), &cprops as *const af_cell);
-            HANDLE_ERROR(AfError::from(err_val));
-        }
+
+        let err_val =
+            unsafe { af_draw_plot_nd(self.handle, points.get(), &cprops as *const af_cell) };
+        HANDLE_ERROR(AfError::from(err_val));
     }
 
     /// Render given Array as a histogram
@@ -719,16 +708,17 @@ impl Window {
             title: tstr.as_ptr(),
             cmap: self.cmap as u32,
         };
-        unsafe {
-            let err_val = af_draw_hist(
+
+        let err_val = unsafe {
+            af_draw_hist(
                 self.handle,
                 hst.get(),
                 minval,
                 maxval,
                 &cprops as *const af_cell,
-            );
-            HANDLE_ERROR(AfError::from(err_val));
-        }
+            )
+        };
+        HANDLE_ERROR(AfError::from(err_val));
     }
 
     /// Render give Arrays as 3d surface
@@ -760,16 +750,17 @@ impl Window {
             title: tstr.as_ptr(),
             cmap: self.cmap as u32,
         };
-        unsafe {
-            let err_val = af_draw_surface(
+
+        let err_val = unsafe {
+            af_draw_surface(
                 self.handle,
                 xvals.get(),
                 yvals.get(),
                 zvals.get(),
                 &cprops as *const af_cell,
-            );
-            HANDLE_ERROR(AfError::from(err_val));
-        }
+            )
+        };
+        HANDLE_ERROR(AfError::from(err_val));
     }
 
     /// Render given Arrays as 2d scatter plot
@@ -801,16 +792,17 @@ impl Window {
             title: tstr.as_ptr(),
             cmap: self.cmap as u32,
         };
-        unsafe {
-            let err_val = af_draw_scatter_2d(
+
+        let err_val = unsafe {
+            af_draw_scatter_2d(
                 self.handle,
                 xvals.get(),
                 yvals.get(),
                 marker as c_uint,
                 &cprops as *const af_cell,
-            );
-            HANDLE_ERROR(AfError::from(err_val));
-        }
+            )
+        };
+        HANDLE_ERROR(AfError::from(err_val));
     }
 
     /// Render given Arrays as 3d scatter plot
@@ -844,17 +836,18 @@ impl Window {
             title: tstr.as_ptr(),
             cmap: self.cmap as u32,
         };
-        unsafe {
-            let err_val = af_draw_scatter_3d(
+
+        let err_val = unsafe {
+            af_draw_scatter_3d(
                 self.handle,
                 xvals.get(),
                 yvals.get(),
                 zvals.get(),
                 marker as c_uint,
                 &cprops as *const af_cell,
-            );
-            HANDLE_ERROR(AfError::from(err_val));
-        }
+            )
+        };
+        HANDLE_ERROR(AfError::from(err_val));
     }
 
     /// Render give Array as 3d scatter plot
@@ -880,15 +873,16 @@ impl Window {
             title: tstr.as_ptr(),
             cmap: self.cmap as u32,
         };
-        unsafe {
-            let err_val = af_draw_scatter_nd(
+
+        let err_val = unsafe {
+            af_draw_scatter_nd(
                 self.handle,
                 vals.get(),
                 marker as c_uint,
                 &cprops as *const af_cell,
-            );
-            HANDLE_ERROR(AfError::from(err_val));
-        }
+            )
+        };
+        HANDLE_ERROR(AfError::from(err_val));
     }
 
     /// Render given Arrays as 2d vector field
@@ -922,17 +916,18 @@ impl Window {
             title: tstr.as_ptr(),
             cmap: self.cmap as u32,
         };
-        unsafe {
-            let err_val = af_draw_vector_field_2d(
+
+        let err_val = unsafe {
+            af_draw_vector_field_2d(
                 self.handle,
                 xpnts.get(),
                 ypnts.get(),
                 xdirs.get(),
                 ydirs.get(),
                 &cprops as *const af_cell,
-            );
-            HANDLE_ERROR(AfError::from(err_val));
-        }
+            )
+        };
+        HANDLE_ERROR(AfError::from(err_val));
     }
 
     /// Render given Arrays as 3d vector field
@@ -971,8 +966,9 @@ impl Window {
             title: tstr.as_ptr(),
             cmap: self.cmap as u32,
         };
-        unsafe {
-            let err_val = af_draw_vector_field_3d(
+
+        let err_val = unsafe {
+            af_draw_vector_field_3d(
                 self.handle,
                 xpnts.get(),
                 ypnts.get(),
@@ -981,9 +977,9 @@ impl Window {
                 ydirs.get(),
                 zdirs.get(),
                 &cprops as *const af_cell,
-            );
-            HANDLE_ERROR(AfError::from(err_val));
-        }
+            )
+        };
+        HANDLE_ERROR(AfError::from(err_val));
     }
 
     /// Render given Array as vector field
@@ -1014,14 +1010,15 @@ impl Window {
             title: tstr.as_ptr(),
             cmap: self.cmap as u32,
         };
-        unsafe {
-            let err_val = af_draw_vector_field_nd(
+
+        let err_val = unsafe {
+            af_draw_vector_field_nd(
                 self.handle,
                 points.get(),
                 directions.get(),
                 &cprops as *const af_cell,
-            );
-            HANDLE_ERROR(AfError::from(err_val));
-        }
+            )
+        };
+        HANDLE_ERROR(AfError::from(err_val));
     }
 }
diff --git a/src/image/mod.rs b/src/image/mod.rs
index 831e18cad..0b0e3ba34 100644
--- a/src/image/mod.rs
+++ b/src/image/mod.rs
@@ -276,17 +276,17 @@ pub fn gradient<T>(input: &Array<T>) -> (Array<T>, Array<T>)
 where
     T: HasAfEnum + FloatingPoint,
 {
-    unsafe {
-        let mut dx: af_array = std::ptr::null_mut();
-        let mut dy: af_array = std::ptr::null_mut();
-        let err_val = af_gradient(
+    let mut dx: af_array = std::ptr::null_mut();
+    let mut dy: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_gradient(
             &mut dx as *mut af_array,
             &mut dy as *mut af_array,
             input.get(),
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        (dx.into(), dy.into())
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    (dx.into(), dy.into())
 }
 
 /// Load Image into Array
@@ -311,17 +311,16 @@ where
         Err(_) => panic!("CString creation from input filename failed"),
     };
     let trgt_type = T::get_af_dtype();
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err1 = af_load_image(&mut temp as *mut af_array, cstr_param.as_ptr(), is_color);
-        HANDLE_ERROR(AfError::from(err1));
 
-        let mut img: af_array = std::ptr::null_mut();
-        let err2 = af_cast(&mut img as *mut af_array, temp, trgt_type as c_uint);
-        HANDLE_ERROR(AfError::from(err2));
+    let mut temp: af_array = std::ptr::null_mut();
+    let err1 = unsafe { af_load_image(&mut temp as *mut af_array, cstr_param.as_ptr(), is_color) };
+    HANDLE_ERROR(AfError::from(err1));
 
-        img.into()
-    }
+    let mut img: af_array = std::ptr::null_mut();
+    let err2 = unsafe { af_cast(&mut img as *mut af_array, temp, trgt_type as c_uint) };
+    HANDLE_ERROR(AfError::from(err2));
+
+    img.into()
 }
 
 /// Load Image into Array in it's native type
@@ -352,17 +351,16 @@ where
         Err(_) => panic!("CString creation from input filename failed"),
     };
     let trgt_type = T::get_af_dtype();
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err1 = af_load_image_native(&mut temp as *mut af_array, cstr_param.as_ptr());
-        HANDLE_ERROR(AfError::from(err1));
 
-        let mut img: af_array = std::ptr::null_mut();
-        let err2 = af_cast(&mut img as *mut af_array, temp, trgt_type as c_uint);
-        HANDLE_ERROR(AfError::from(err2));
+    let mut temp: af_array = std::ptr::null_mut();
+    let err1 = unsafe { af_load_image_native(&mut temp as *mut af_array, cstr_param.as_ptr()) };
+    HANDLE_ERROR(AfError::from(err1));
 
-        img.into()
-    }
+    let mut img: af_array = std::ptr::null_mut();
+    let err2 = unsafe { af_cast(&mut img as *mut af_array, temp, trgt_type as c_uint) };
+    HANDLE_ERROR(AfError::from(err2));
+
+    img.into()
 }
 
 /// Save an Array to an image file
@@ -380,10 +378,9 @@ where
         Ok(cstr) => cstr,
         Err(_) => panic!("CString creation from input filename failed"),
     };
-    unsafe {
-        let err_val = af_save_image(cstr_param.as_ptr(), input.get());
-        HANDLE_ERROR(AfError::from(err_val));
-    }
+
+    let err_val = unsafe { af_save_image(cstr_param.as_ptr(), input.get()) };
+    HANDLE_ERROR(AfError::from(err_val));
 }
 
 /// Save an Array without modifications to an image file
@@ -411,10 +408,9 @@ where
         Ok(cstr) => cstr,
         Err(_) => panic!("CString creation from input filename failed"),
     };
-    unsafe {
-        let err_val = af_save_image_native(cstr_param.as_ptr(), input.get());
-        HANDLE_ERROR(AfError::from(err_val));
-    }
+
+    let err_val = unsafe { af_save_image_native(cstr_param.as_ptr(), input.get()) };
+    HANDLE_ERROR(AfError::from(err_val));
 }
 
 /// Resize an Image
@@ -443,18 +439,18 @@ pub fn resize<T: HasAfEnum>(
     odim1: i64,
     method: InterpType,
 ) -> Array<T> {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_resize(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_resize(
             &mut temp as *mut af_array,
             input.get(),
             odim0 as dim_t,
             odim1 as dim_t,
             method as c_uint,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Transform(Affine) an Image
@@ -494,9 +490,9 @@ pub fn transform<T: HasAfEnum>(
     method: InterpType,
     is_inverse: bool,
 ) -> Array<T> {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_transform(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_transform(
             &mut temp as *mut af_array,
             input.get(),
             trans.get(),
@@ -504,10 +500,10 @@ pub fn transform<T: HasAfEnum>(
             odim1 as dim_t,
             method as c_uint,
             is_inverse,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Rotate an Image
@@ -545,18 +541,18 @@ pub fn rotate<T: HasAfEnum>(
     crop: bool,
     method: InterpType,
 ) -> Array<T> {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_rotate(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_rotate(
             &mut temp as *mut af_array,
             input.get(),
             theta as c_float,
             crop,
             method as c_uint,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Translate an Image
@@ -594,9 +590,9 @@ pub fn translate<T: HasAfEnum>(
     odim1: i64,
     method: InterpType,
 ) -> Array<T> {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_translate(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_translate(
             &mut temp as *mut af_array,
             input.get(),
             trans0,
@@ -604,10 +600,10 @@ pub fn translate<T: HasAfEnum>(
             odim0 as dim_t,
             odim1 as dim_t,
             method as c_uint,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Scale an Image
@@ -636,9 +632,9 @@ pub fn scale<T: HasAfEnum>(
     odim1: i64,
     method: InterpType,
 ) -> Array<T> {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_scale(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_scale(
             &mut temp as *mut af_array,
             input.get(),
             scale0,
@@ -646,10 +642,10 @@ pub fn scale<T: HasAfEnum>(
             odim0 as dim_t,
             odim1 as dim_t,
             method as c_uint,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Skew an image
@@ -685,9 +681,9 @@ pub fn skew<T: HasAfEnum>(
     method: InterpType,
     is_inverse: bool,
 ) -> Array<T> {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_skew(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_skew(
             &mut temp as *mut af_array,
             input.get(),
             skew0,
@@ -696,10 +692,10 @@ pub fn skew<T: HasAfEnum>(
             odim1 as dim_t,
             method as c_uint,
             is_inverse,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Compute Histogram of an Array
@@ -729,18 +725,18 @@ pub fn histogram<T>(input: &Array<T>, nbins: u32, minval: f64, maxval: f64) -> A
 where
     T: HasAfEnum + RealNumber,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_histogram(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_histogram(
             &mut temp as *mut af_array,
             input.get(),
             nbins,
             minval,
             maxval,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Dilate an Image
@@ -766,12 +762,10 @@ pub fn dilate<T>(input: &Array<T>, mask: &Array<T>) -> Array<T>
 where
     T: HasAfEnum + ImageFilterType,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_dilate(&mut temp as *mut af_array, input.get(), mask.get());
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe { af_dilate(&mut temp as *mut af_array, input.get(), mask.get()) };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Erode an Image
@@ -798,12 +792,10 @@ pub fn erode<T>(input: &Array<T>, mask: &Array<T>) -> Array<T>
 where
     T: HasAfEnum + ImageFilterType,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_erode(&mut temp as *mut af_array, input.get(), mask.get());
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe { af_erode(&mut temp as *mut af_array, input.get(), mask.get()) };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Dilate a Volume
@@ -823,12 +815,10 @@ pub fn dilate3<T>(input: &Array<T>, mask: &Array<T>) -> Array<T>
 where
     T: HasAfEnum + ImageFilterType,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_dilate3(&mut temp as *mut af_array, input.get(), mask.get());
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe { af_dilate3(&mut temp as *mut af_array, input.get(), mask.get()) };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Erode a Volume
@@ -848,12 +838,10 @@ pub fn erode3<T>(input: &Array<T>, mask: &Array<T>) -> Array<T>
 where
     T: HasAfEnum + ImageFilterType,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_erode3(&mut temp as *mut af_array, input.get(), mask.get());
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe { af_erode3(&mut temp as *mut af_array, input.get(), mask.get()) };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Bilateral Filter.
@@ -885,18 +873,18 @@ where
     T: HasAfEnum + ImageFilterType,
     T::AbsOutType: HasAfEnum,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_bilateral(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_bilateral(
             &mut temp as *mut af_array,
             input.get(),
             spatial_sigma,
             chromatic_sigma,
             iscolor,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Meanshift Filter.
@@ -929,19 +917,19 @@ pub fn mean_shift<T>(
 where
     T: HasAfEnum + RealNumber,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_mean_shift(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_mean_shift(
             &mut temp as *mut af_array,
             input.get(),
             spatial_sigma,
             chromatic_sigma,
             iter,
             iscolor,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 macro_rules! filt_func_def {
@@ -962,18 +950,18 @@ macro_rules! filt_func_def {
         where
             T: HasAfEnum + ImageFilterType,
         {
-            unsafe {
-                let mut temp: af_array = std::ptr::null_mut();
-                let err_val = $ffi_name(
+            let mut temp: af_array = std::ptr::null_mut();
+            let err_val = unsafe {
+                $ffi_name(
                     &mut temp as *mut af_array,
                     input.get(),
                     wlen as dim_t,
                     wwid as dim_t,
                     etype as c_uint,
-                );
-                HANDLE_ERROR(AfError::from(err_val));
-                temp.into()
-            }
+                )
+            };
+            HANDLE_ERROR(AfError::from(err_val));
+            temp.into()
         }
     };
 }
@@ -1012,12 +1000,11 @@ filt_func_def!(
 ///
 /// An Array with gaussian kernel values
 pub fn gaussian_kernel(rows: i32, cols: i32, sigma_r: f64, sigma_c: f64) -> Array<f32> {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_gaussian_kernel(&mut temp as *mut af_array, rows, cols, sigma_r, sigma_c);
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val =
+        unsafe { af_gaussian_kernel(&mut temp as *mut af_array, rows, cols, sigma_r, sigma_c) };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Color space conversion
@@ -1058,17 +1045,17 @@ pub fn color_space<T>(input: &Array<T>, tospace: ColorSpace, fromspace: ColorSpa
 where
     T: HasAfEnum + RealNumber,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_color_space(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_color_space(
             &mut temp as *mut af_array,
             input.get(),
             tospace as c_uint,
             fromspace as c_uint,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Find blobs in given image.
@@ -1093,17 +1080,18 @@ where
     OutType: HasAfEnum + RealNumber,
 {
     let otype = OutType::get_af_dtype();
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_regions(
+
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_regions(
             &mut temp as *mut af_array,
             input.get(),
             conn as c_uint,
             otype as c_uint,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Sobel Operator
@@ -1128,18 +1116,18 @@ where
     T: HasAfEnum + ImageFilterType,
     T::SobelOutType: HasAfEnum,
 {
-    unsafe {
-        let mut dx: af_array = std::ptr::null_mut();
-        let mut dy: af_array = std::ptr::null_mut();
-        let err_val = af_sobel_operator(
+    let mut dx: af_array = std::ptr::null_mut();
+    let mut dy: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_sobel_operator(
             &mut dx as *mut af_array,
             &mut dy as *mut af_array,
             input.get(),
             ker_size,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        (dx.into(), dy.into())
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    (dx.into(), dy.into())
 }
 
 /// Histogram Equalization
@@ -1155,12 +1143,10 @@ pub fn hist_equal<T>(input: &Array<T>, hist: &Array<u32>) -> Array<T>
 where
     T: HasAfEnum + RealNumber,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_hist_equal(&mut temp as *mut af_array, input.get(), hist.get());
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe { af_hist_equal(&mut temp as *mut af_array, input.get(), hist.get()) };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 macro_rules! grayrgb_func_def {
@@ -1180,12 +1166,10 @@ macro_rules! grayrgb_func_def {
         where
             T: HasAfEnum + GrayRGBConvertible,
         {
-            unsafe {
-                let mut temp: af_array = std::ptr::null_mut();
-                let err_val = $ffi_name(&mut temp as *mut af_array, input.get(), r, g, b);
-                HANDLE_ERROR(AfError::from(err_val));
-                temp.into()
-            }
+            let mut temp: af_array = std::ptr::null_mut();
+            let err_val = unsafe { $ffi_name(&mut temp as *mut af_array, input.get(), r, g, b) };
+            HANDLE_ERROR(AfError::from(err_val));
+            temp.into()
         }
     };
 }
@@ -1200,12 +1184,10 @@ macro_rules! hsvrgb_func_def {
         where
             T: HasAfEnum + RealFloating,
         {
-            unsafe {
-                let mut temp: af_array = std::ptr::null_mut();
-                let err_val = $ffi_name(&mut temp as *mut af_array, input.get());
-                HANDLE_ERROR(AfError::from(err_val));
-                temp.into()
-            }
+            let mut temp: af_array = std::ptr::null_mut();
+            let err_val = unsafe { $ffi_name(&mut temp as *mut af_array, input.get()) };
+            HANDLE_ERROR(AfError::from(err_val));
+            temp.into()
         }
     };
 }
@@ -1294,9 +1276,9 @@ pub fn unwrap<T: HasAfEnum>(
     py: i64,
     is_column: bool,
 ) -> Array<T> {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_unwrap(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_unwrap(
             &mut temp as *mut af_array,
             input.get(),
             wx,
@@ -1306,10 +1288,10 @@ pub fn unwrap<T: HasAfEnum>(
             px,
             py,
             is_column,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Converts unwrapped image to an image
@@ -1348,9 +1330,9 @@ pub fn wrap<T: HasAfEnum>(
     py: i64,
     is_column: bool,
 ) -> Array<T> {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_wrap(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_wrap(
             &mut temp as *mut af_array,
             input.get(),
             ox,
@@ -1362,10 +1344,10 @@ pub fn wrap<T: HasAfEnum>(
             px,
             py,
             is_column,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Summed area table of an Image
@@ -1382,12 +1364,10 @@ where
     T: HasAfEnum + RealNumber,
     T::AggregateOutType: HasAfEnum,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_sat(&mut temp as *mut af_array, input.get());
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe { af_sat(&mut temp as *mut af_array, input.get()) };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// RGB to YCbCr colorspace converter.
@@ -1414,12 +1394,11 @@ pub fn rgb2ycbcr<T>(input: &Array<T>, standard: YCCStd) -> Array<T>
 where
     T: HasAfEnum + RealFloating,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_rgb2ycbcr(&mut temp as *mut af_array, input.get(), standard as c_uint);
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val =
+        unsafe { af_rgb2ycbcr(&mut temp as *mut af_array, input.get(), standard as c_uint) };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// YCbCr to RGB colorspace converter.
@@ -1452,12 +1431,11 @@ pub fn ycbcr2rgb<T>(input: &Array<T>, standard: YCCStd) -> Array<T>
 where
     T: HasAfEnum + RealFloating,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_ycbcr2rgb(&mut temp as *mut af_array, input.get(), standard as c_uint);
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val =
+        unsafe { af_ycbcr2rgb(&mut temp as *mut af_array, input.get(), standard as c_uint) };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Function to check if Image I/O is available
@@ -1498,12 +1476,10 @@ pub fn transform_coords<T>(tf: &Array<T>, d0: f32, d1: f32) -> Array<T>
 where
     T: HasAfEnum + RealFloating,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_transform_coordinates(&mut temp as *mut af_array, tf.get(), d0, d1);
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe { af_transform_coordinates(&mut temp as *mut af_array, tf.get(), d0, d1) };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Find Image moments
@@ -1521,12 +1497,10 @@ pub fn moments<T>(input: &Array<T>, moment: MomentType) -> Array<f32>
 where
     T: HasAfEnum + MomentsComputable,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_moments(&mut temp as *mut af_array, input.get(), moment as c_uint);
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe { af_moments(&mut temp as *mut af_array, input.get(), moment as c_uint) };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Find Image moment for whole image
@@ -1545,10 +1519,11 @@ where
     T: HasAfEnum + MomentsComputable,
 {
     let mut temp: f64 = 0.0;
-    unsafe {
-        let err_val = af_moments_all(&mut temp as *mut c_double, input.get(), moment as c_uint);
-        HANDLE_ERROR(AfError::from(err_val));
-    }
+
+    let err_val =
+        unsafe { af_moments_all(&mut temp as *mut c_double, input.get(), moment as c_uint) };
+    HANDLE_ERROR(AfError::from(err_val));
+
     temp
 }
 
@@ -1567,17 +1542,17 @@ pub fn medfilt1<T>(input: &Array<T>, wlen: u64, etype: BorderType) -> Array<T>
 where
     T: HasAfEnum + ImageFilterType,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_medfilt1(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_medfilt1(
             &mut temp as *mut af_array,
             input.get(),
             wlen as dim_t,
             etype as c_uint,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Canny edge detection operator
@@ -1608,9 +1583,9 @@ pub fn canny<T>(
 where
     T: HasAfEnum + EdgeComputable,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_canny(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_canny(
             &mut temp as *mut af_array,
             input.get(),
             threshold_type as c_int,
@@ -1618,10 +1593,10 @@ where
             high,
             sobel_window as c_uint,
             is_fast,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Anisotropic smoothing filter
@@ -1710,9 +1685,9 @@ where
     T: HasAfEnum + EdgeComputable,
     T::AbsOutType: HasAfEnum,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_anisotropic_diffusion(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_anisotropic_diffusion(
             &mut temp as *mut af_array,
             img.get(),
             dt,
@@ -1720,10 +1695,10 @@ where
             iters,
             fftype as c_uint,
             diff_kind as c_uint,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Segment image based on similar pixel characteristics
@@ -1781,9 +1756,9 @@ pub fn confidence_cc<InOutType>(
 where
     InOutType: ConfidenceCCInput,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_confidence_cc(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_confidence_cc(
             &mut temp as *mut af_array,
             input.get(),
             seedx.get(),
@@ -1792,10 +1767,10 @@ where
             multiplier,
             iterations as i32,
             segmented_val,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Iterative Deconvolution
@@ -1844,19 +1819,19 @@ where
     T: DeconvInput,
     T::AbsOutType: HasAfEnum,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_iterative_deconv(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_iterative_deconv(
             &mut temp as *mut af_array,
             input.get(),
             kernel.get(),
             iterations,
             relaxation_factor,
             algo as c_uint,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Inverse deconvolution
@@ -1897,16 +1872,16 @@ where
     T: DeconvInput,
     T::AbsOutType: HasAfEnum,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_inverse_deconv(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_inverse_deconv(
             &mut temp as *mut af_array,
             input.get(),
             kernel.get(),
             gamma,
             algo as c_uint,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
diff --git a/src/lapack/mod.rs b/src/lapack/mod.rs
index 457877812..1866108fe 100644
--- a/src/lapack/mod.rs
+++ b/src/lapack/mod.rs
@@ -73,19 +73,19 @@ where
     T: HasAfEnum + FloatingPoint,
     T::BaseType: HasAfEnum,
 {
-    unsafe {
-        let mut u: af_array = std::ptr::null_mut();
-        let mut s: af_array = std::ptr::null_mut();
-        let mut vt: af_array = std::ptr::null_mut();
-        let err_val = af_svd(
+    let mut u: af_array = std::ptr::null_mut();
+    let mut s: af_array = std::ptr::null_mut();
+    let mut vt: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_svd(
             &mut u as *mut af_array,
             &mut s as *mut af_array,
             &mut vt as *mut af_array,
             input.get(),
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        (u.into(), s.into(), vt.into())
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    (u.into(), s.into(), vt.into())
 }
 
 /// Perform Singular Value Decomposition inplace
@@ -117,19 +117,19 @@ where
     T: HasAfEnum + FloatingPoint,
     T::BaseType: HasAfEnum,
 {
-    unsafe {
-        let mut u: af_array = std::ptr::null_mut();
-        let mut s: af_array = std::ptr::null_mut();
-        let mut vt: af_array = std::ptr::null_mut();
-        let err_val = af_svd_inplace(
+    let mut u: af_array = std::ptr::null_mut();
+    let mut s: af_array = std::ptr::null_mut();
+    let mut vt: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_svd_inplace(
             &mut u as *mut af_array,
             &mut s as *mut af_array,
             &mut vt as *mut af_array,
             input.get(),
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        (u.into(), s.into(), vt.into())
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    (u.into(), s.into(), vt.into())
 }
 
 /// Perform LU decomposition
@@ -151,19 +151,19 @@ pub fn lu<T>(input: &Array<T>) -> (Array<T>, Array<T>, Array<i32>)
 where
     T: HasAfEnum + FloatingPoint,
 {
-    unsafe {
-        let mut lower: af_array = std::ptr::null_mut();
-        let mut upper: af_array = std::ptr::null_mut();
-        let mut pivot: af_array = std::ptr::null_mut();
-        let err_val = af_lu(
+    let mut lower: af_array = std::ptr::null_mut();
+    let mut upper: af_array = std::ptr::null_mut();
+    let mut pivot: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_lu(
             &mut lower as *mut af_array,
             &mut upper as *mut af_array,
             &mut pivot as *mut af_array,
             input.get(),
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        (lower.into(), upper.into(), pivot.into())
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    (lower.into(), upper.into(), pivot.into())
 }
 
 /// Perform inplace LU decomposition
@@ -181,12 +181,10 @@ pub fn lu_inplace<T>(input: &mut Array<T>, is_lapack_piv: bool) -> Array<i32>
 where
     T: HasAfEnum + FloatingPoint,
 {
-    unsafe {
-        let mut pivot: af_array = std::ptr::null_mut();
-        let err_val = af_lu_inplace(&mut pivot as *mut af_array, input.get(), is_lapack_piv);
-        HANDLE_ERROR(AfError::from(err_val));
-        pivot.into()
-    }
+    let mut pivot: af_array = std::ptr::null_mut();
+    let err_val = unsafe { af_lu_inplace(&mut pivot as *mut af_array, input.get(), is_lapack_piv) };
+    HANDLE_ERROR(AfError::from(err_val));
+    pivot.into()
 }
 
 /// Perform QR decomposition
@@ -209,19 +207,19 @@ pub fn qr<T>(input: &Array<T>) -> (Array<T>, Array<T>, Array<T>)
 where
     T: HasAfEnum + FloatingPoint,
 {
-    unsafe {
-        let mut q: af_array = std::ptr::null_mut();
-        let mut r: af_array = std::ptr::null_mut();
-        let mut tau: af_array = std::ptr::null_mut();
-        let err_val = af_qr(
+    let mut q: af_array = std::ptr::null_mut();
+    let mut r: af_array = std::ptr::null_mut();
+    let mut tau: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_qr(
             &mut q as *mut af_array,
             &mut r as *mut af_array,
             &mut tau as *mut af_array,
             input.get(),
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        (q.into(), r.into(), tau.into())
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    (q.into(), r.into(), tau.into())
 }
 
 /// Perform inplace QR decomposition
@@ -237,12 +235,10 @@ pub fn qr_inplace<T>(input: &mut Array<T>) -> Array<T>
 where
     T: HasAfEnum + FloatingPoint,
 {
-    unsafe {
-        let mut tau: af_array = std::ptr::null_mut();
-        let err_val = af_qr_inplace(&mut tau as *mut af_array, input.get());
-        HANDLE_ERROR(AfError::from(err_val));
-        tau.into()
-    }
+    let mut tau: af_array = std::ptr::null_mut();
+    let err_val = unsafe { af_qr_inplace(&mut tau as *mut af_array, input.get()) };
+    HANDLE_ERROR(AfError::from(err_val));
+    tau.into()
 }
 
 /// Perform Cholesky decomposition
@@ -264,18 +260,18 @@ pub fn cholesky<T>(input: &Array<T>, is_upper: bool) -> (Array<T>, i32)
 where
     T: HasAfEnum + FloatingPoint,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let mut info: i32 = 0;
-        let err_val = af_cholesky(
+    let mut temp: af_array = std::ptr::null_mut();
+    let mut info: i32 = 0;
+    let err_val = unsafe {
+        af_cholesky(
             &mut temp as *mut af_array,
             &mut info as *mut c_int,
             input.get(),
             is_upper,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        (temp.into(), info)
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    (temp.into(), info)
 }
 
 /// Perform inplace Cholesky decomposition
@@ -294,10 +290,10 @@ where
     T: HasAfEnum + FloatingPoint,
 {
     let mut info: i32 = 0;
-    unsafe {
-        let err_val = af_cholesky_inplace(&mut info as *mut c_int, input.get(), is_upper);
-        HANDLE_ERROR(AfError::from(err_val));
-    }
+
+    let err_val = unsafe { af_cholesky_inplace(&mut info as *mut c_int, input.get(), is_upper) };
+    HANDLE_ERROR(AfError::from(err_val));
+
     info
 }
 
@@ -318,17 +314,17 @@ pub fn solve<T>(a: &Array<T>, b: &Array<T>, options: MatProp) -> Array<T>
 where
     T: HasAfEnum + FloatingPoint,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_solve(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_solve(
             &mut temp as *mut af_array,
             a.get(),
             b.get(),
             options as c_uint,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Solve a system of equations
@@ -349,18 +345,18 @@ pub fn solve_lu<T>(a: &Array<T>, piv: &Array<i32>, b: &Array<T>, options: MatPro
 where
     T: HasAfEnum + FloatingPoint,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_solve_lu(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_solve_lu(
             &mut temp as *mut af_array,
             a.get(),
             piv.get(),
             b.get(),
             options as c_uint,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Compute inverse of a matrix
@@ -379,12 +375,10 @@ pub fn inverse<T>(input: &Array<T>, options: MatProp) -> Array<T>
 where
     T: HasAfEnum + FloatingPoint,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_inverse(&mut temp as *mut af_array, input.get(), options as c_uint);
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe { af_inverse(&mut temp as *mut af_array, input.get(), options as c_uint) };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Find rank of a matrix
@@ -402,10 +396,10 @@ where
     T: HasAfEnum + FloatingPoint,
 {
     let mut temp: u32 = 0;
-    unsafe {
-        let err_val = af_rank(&mut temp as *mut c_uint, input.get(), tol);
-        HANDLE_ERROR(AfError::from(err_val));
-    }
+
+    let err_val = unsafe { af_rank(&mut temp as *mut c_uint, input.get(), tol) };
+    HANDLE_ERROR(AfError::from(err_val));
+
     temp
 }
 
@@ -426,14 +420,16 @@ where
 {
     let mut real: f64 = 0.0;
     let mut imag: f64 = 0.0;
-    unsafe {
-        let err_val = af_det(
+
+    let err_val = unsafe {
+        af_det(
             &mut real as *mut c_double,
             &mut imag as *mut c_double,
             input.get(),
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+
     (real, imag)
 }
 
@@ -456,16 +452,18 @@ where
     T: HasAfEnum + FloatingPoint,
 {
     let mut out: f64 = 0.0;
-    unsafe {
-        let err_val = af_norm(
+
+    let err_val = unsafe {
+        af_norm(
             &mut out as *mut c_double,
             input.get(),
             ntype as c_uint,
             p,
             q,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+
     out
 }
 
@@ -507,15 +505,15 @@ pub fn pinverse<T>(input: &Array<T>, tolerance: f64, option: MatProp) -> Array<T
 where
     T: HasAfEnum + FloatingPoint,
 {
-    unsafe {
-        let mut out: af_array = std::ptr::null_mut();
-        let err_val = af_pinverse(
+    let mut out: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_pinverse(
             &mut out as *mut af_array,
             input.get(),
             tolerance,
             option as c_uint,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        out.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    out.into()
 }
diff --git a/src/ml/mod.rs b/src/ml/mod.rs
index baa2688a0..b36e8ba77 100644
--- a/src/ml/mod.rs
+++ b/src/ml/mod.rs
@@ -70,9 +70,9 @@ pub fn convolve2_nn<T>(
 where
     T: HasAfEnum + RealFloating,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_convolve2_nn(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_convolve2_nn(
             &mut temp as *mut af_array,
             signal.get(),
             filter.get(),
@@ -82,10 +82,10 @@ where
             padding.get().as_ptr() as *const dim_t,
             2,
             dilation.get().as_ptr() as *const dim_t,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Backward pass gradient of 2D convolution
@@ -118,9 +118,9 @@ pub fn convolve2_gradient_nn<T>(
 where
     T: HasAfEnum + RealFloating,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_convolve2_gradient_nn(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_convolve2_gradient_nn(
             &mut temp as *mut af_array,
             incoming_grad.get(),
             original_signal.get(),
@@ -133,8 +133,8 @@ where
             2,
             dilation.get().as_ptr() as *const dim_t,
             grad_type as c_uint,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
diff --git a/src/signal/mod.rs b/src/signal/mod.rs
index 6933c92c3..1a1529a20 100644
--- a/src/signal/mod.rs
+++ b/src/signal/mod.rs
@@ -201,18 +201,18 @@ where
     T: HasAfEnum + FloatingPoint,
     P: HasAfEnum + RealFloating,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_approx1(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_approx1(
             &mut temp as *mut af_array,
             input.get(),
             pos.get(),
             method as c_uint,
             off_grid,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Same as [approx1](./fn.approx1.html) but uses existing Array as output
@@ -226,16 +226,16 @@ pub fn approx1_v2<T, P>(
     T: HasAfEnum + FloatingPoint,
     P: HasAfEnum + RealFloating,
 {
-    unsafe {
-        let err_val = af_approx1_v2(
+    let err_val = unsafe {
+        af_approx1_v2(
             output.get() as *mut af_array,
             input.get(),
             pos.get(),
             method as c_uint,
             off_grid,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
 }
 
 /// Perform signal interpolation for 1d signals along specified dimension
@@ -267,9 +267,9 @@ where
     T: HasAfEnum + FloatingPoint,
     P: HasAfEnum + RealFloating,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_approx1_uniform(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_approx1_uniform(
             &mut temp as *mut af_array,
             input.get(),
             pos.get(),
@@ -278,10 +278,10 @@ where
             step,
             method as c_uint,
             off_grid,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Same as [approx1_uniform](./fn.approx1_uniform.html) but uses existing Array as output
@@ -299,8 +299,8 @@ pub fn approx1_uniform_v2<T, P>(
     T: HasAfEnum + FloatingPoint,
     P: HasAfEnum + RealFloating,
 {
-    unsafe {
-        let err_val = af_approx1_uniform_v2(
+    let err_val = unsafe {
+        af_approx1_uniform_v2(
             output.get() as *mut af_array,
             input.get(),
             pos.get(),
@@ -309,9 +309,9 @@ pub fn approx1_uniform_v2<T, P>(
             step,
             method as c_uint,
             off_grid,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
 }
 
 /// Perform signal interpolation for 2d signals
@@ -339,19 +339,19 @@ where
     T: HasAfEnum + FloatingPoint,
     P: HasAfEnum + RealFloating,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_approx2(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_approx2(
             &mut temp as *mut af_array,
             input.get(),
             pos0.get(),
             pos1.get(),
             method as c_uint,
             off_grid,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Same as [approx2](./fn.approx2.html) but uses existing Array as output
@@ -366,17 +366,17 @@ pub fn approx2_v2<T, P>(
     T: HasAfEnum + FloatingPoint,
     P: HasAfEnum + RealFloating,
 {
-    unsafe {
-        let err_val = af_approx2_v2(
+    let err_val = unsafe {
+        af_approx2_v2(
             output.get() as *mut af_array,
             input.get(),
             pos0.get(),
             pos1.get(),
             method as c_uint,
             off_grid,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
 }
 
 /// Perform signal interpolation for 2d signals along a specified dimension
@@ -417,9 +417,9 @@ where
     T: HasAfEnum + FloatingPoint,
     P: HasAfEnum + RealFloating,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_approx2_uniform(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_approx2_uniform(
             &mut temp as *mut af_array,
             input.get(),
             pos0.get(),
@@ -432,10 +432,10 @@ where
             step1,
             method as c_uint,
             off_grid,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Same as [approx2_uniform](./fn.approx2_uniform.html) but uses existing Array as output
@@ -457,8 +457,8 @@ pub fn approx2_uniform_v2<T, P>(
     T: HasAfEnum + FloatingPoint,
     P: HasAfEnum + RealFloating,
 {
-    unsafe {
-        let err_val = af_approx2_uniform_v2(
+    let err_val = unsafe {
+        af_approx2_uniform_v2(
             output.get() as *mut af_array,
             input.get(),
             pos0.get(),
@@ -471,9 +471,9 @@ pub fn approx2_uniform_v2<T, P>(
             step1,
             method as c_uint,
             off_grid,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
 }
 
 /// Set fft plan cache size
@@ -482,10 +482,8 @@ pub fn approx2_uniform_v2<T, P>(
 /// the fft plan cache size a mid program execution unless that is what
 /// you intend to do.
 pub fn set_fft_plan_cache_size(cache_size: usize) {
-    unsafe {
-        let err_val = af_set_fft_plan_cache_size(cache_size as size_t);
-        HANDLE_ERROR(AfError::from(err_val));
-    }
+    let err_val = unsafe { af_set_fft_plan_cache_size(cache_size as size_t) };
+    HANDLE_ERROR(AfError::from(err_val));
 }
 
 /// Fast fourier transform for 1d signals
@@ -506,12 +504,10 @@ where
     T: HasAfEnum + FloatingPoint,
     <T as HasAfEnum>::ComplexOutType: HasAfEnum,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_fft(&mut temp as *mut af_array, input.get(), norm_factor, odim0);
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe { af_fft(&mut temp as *mut af_array, input.get(), norm_factor, odim0) };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Fast fourier transform for 2d signals
@@ -537,18 +533,18 @@ where
     T: HasAfEnum + FloatingPoint,
     <T as HasAfEnum>::ComplexOutType: HasAfEnum,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_fft2(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_fft2(
             &mut temp as *mut af_array,
             input.get(),
             norm_factor,
             odim0,
             odim1,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Fast fourier transform for 3d signals
@@ -576,19 +572,19 @@ where
     T: HasAfEnum + FloatingPoint,
     <T as HasAfEnum>::ComplexOutType: HasAfEnum,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_fft3(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_fft3(
             &mut temp as *mut af_array,
             input.get(),
             norm_factor,
             odim0,
             odim1,
             odim2,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Inverse fast fourier transform for 1d signals
@@ -609,12 +605,10 @@ where
     T: HasAfEnum + FloatingPoint,
     <T as HasAfEnum>::ComplexOutType: HasAfEnum,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_ifft(&mut temp as *mut af_array, input.get(), norm_factor, odim0);
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe { af_ifft(&mut temp as *mut af_array, input.get(), norm_factor, odim0) };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Inverse fast fourier transform for 2d signals
@@ -640,18 +634,18 @@ where
     T: HasAfEnum + FloatingPoint,
     <T as HasAfEnum>::ComplexOutType: HasAfEnum,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_ifft2(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_ifft2(
             &mut temp as *mut af_array,
             input.get(),
             norm_factor,
             odim0,
             odim1,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Inverse fast fourier transform for 3d signals
@@ -679,19 +673,19 @@ where
     T: HasAfEnum + FloatingPoint,
     <T as HasAfEnum>::ComplexOutType: HasAfEnum,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_ifft3(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_ifft3(
             &mut temp as *mut af_array,
             input.get(),
             norm_factor,
             odim0,
             odim1,
             odim2,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 macro_rules! conv_func_def {
@@ -720,18 +714,18 @@ macro_rules! conv_func_def {
             T: HasAfEnum,
             F: HasAfEnum,
         {
-            unsafe {
-                let mut temp: af_array = std::ptr::null_mut();
-                let err_val = $ffi_name(
+            let mut temp: af_array = std::ptr::null_mut();
+            let err_val = unsafe {
+                $ffi_name(
                     &mut temp as *mut af_array,
                     signal.get(),
                     filter.get(),
                     mode as c_uint,
                     domain as c_uint,
-                );
-                HANDLE_ERROR(AfError::from(err_val));
-                temp.into()
-            }
+                )
+            };
+            HANDLE_ERROR(AfError::from(err_val));
+            temp.into()
         }
     };
 }
@@ -762,18 +756,18 @@ where
     T: HasAfEnum,
     F: HasAfEnum,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_convolve2_sep(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_convolve2_sep(
             &mut temp as *mut af_array,
             cfilt.get(),
             rfilt.get(),
             signal.get(),
             mode as c_uint,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 macro_rules! fft_conv_func_def {
@@ -795,17 +789,17 @@ macro_rules! fft_conv_func_def {
             T: HasAfEnum,
             F: HasAfEnum,
         {
-            unsafe {
-                let mut temp: af_array = std::ptr::null_mut();
-                let err_val = $ffi_name(
+            let mut temp: af_array = std::ptr::null_mut();
+            let err_val = unsafe {
+                $ffi_name(
                     &mut temp as *mut af_array,
                     signal.get(),
                     filter.get(),
                     mode as c_uint,
-                );
-                HANDLE_ERROR(AfError::from(err_val));
-                temp.into()
-            }
+                )
+            };
+            HANDLE_ERROR(AfError::from(err_val));
+            temp.into()
         }
     };
 }
@@ -841,12 +835,10 @@ where
     B: HasAfEnum,
     X: HasAfEnum,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_fir(&mut temp as *mut af_array, b.get(), x.get());
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe { af_fir(&mut temp as *mut af_array, b.get(), x.get()) };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Infinite impulse response filter
@@ -861,12 +853,10 @@ where
 ///
 /// Filtered Array
 pub fn iir<T: HasAfEnum>(b: &Array<T>, a: &Array<T>, x: &Array<T>) -> Array<T> {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_iir(&mut temp as *mut af_array, b.get(), a.get(), x.get());
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe { af_iir(&mut temp as *mut af_array, b.get(), a.get(), x.get()) };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// In place 1d dimensional Fast fourier transform
@@ -879,10 +869,8 @@ pub fn fft_inplace<T>(input: &mut Array<T>, norm_factor: f64)
 where
     T: HasAfEnum + ComplexFloating,
 {
-    unsafe {
-        let err_val = af_fft_inplace(input.get() as *mut af_array, norm_factor);
-        HANDLE_ERROR(AfError::from(err_val));
-    }
+    let err_val = unsafe { af_fft_inplace(input.get() as *mut af_array, norm_factor) };
+    HANDLE_ERROR(AfError::from(err_val));
 }
 
 /// In place 2d dimensional Fast fourier transform
@@ -895,10 +883,8 @@ pub fn fft2_inplace<T>(input: &mut Array<T>, norm_factor: f64)
 where
     T: HasAfEnum + ComplexFloating,
 {
-    unsafe {
-        let err_val = af_fft2_inplace(input.get() as *mut af_array, norm_factor);
-        HANDLE_ERROR(AfError::from(err_val));
-    }
+    let err_val = unsafe { af_fft2_inplace(input.get() as *mut af_array, norm_factor) };
+    HANDLE_ERROR(AfError::from(err_val));
 }
 
 /// In place 3d dimensional Fast fourier transform
@@ -911,10 +897,8 @@ pub fn fft3_inplace<T>(input: &mut Array<T>, norm_factor: f64)
 where
     T: HasAfEnum + ComplexFloating,
 {
-    unsafe {
-        let err_val = af_fft3_inplace(input.get() as *mut af_array, norm_factor);
-        HANDLE_ERROR(AfError::from(err_val));
-    }
+    let err_val = unsafe { af_fft3_inplace(input.get() as *mut af_array, norm_factor) };
+    HANDLE_ERROR(AfError::from(err_val));
 }
 
 /// In place 1d dimensional inverse fast fourier transform
@@ -927,10 +911,8 @@ pub fn ifft_inplace<T>(input: &mut Array<T>, norm_factor: f64)
 where
     T: HasAfEnum + ComplexFloating,
 {
-    unsafe {
-        let err_val = af_ifft_inplace(input.get() as *mut af_array, norm_factor);
-        HANDLE_ERROR(AfError::from(err_val));
-    }
+    let err_val = unsafe { af_ifft_inplace(input.get() as *mut af_array, norm_factor) };
+    HANDLE_ERROR(AfError::from(err_val));
 }
 
 /// In place 2d dimensional inverse fast fourier transform
@@ -943,10 +925,8 @@ pub fn ifft2_inplace<T>(input: &mut Array<T>, norm_factor: f64)
 where
     T: HasAfEnum + ComplexFloating,
 {
-    unsafe {
-        let err_val = af_ifft2_inplace(input.get() as *mut af_array, norm_factor);
-        HANDLE_ERROR(AfError::from(err_val));
-    }
+    let err_val = unsafe { af_ifft2_inplace(input.get() as *mut af_array, norm_factor) };
+    HANDLE_ERROR(AfError::from(err_val));
 }
 
 /// In place 3d dimensional inverse fast fourier transform
@@ -959,10 +939,8 @@ pub fn ifft3_inplace<T>(input: &mut Array<T>, norm_factor: f64)
 where
     T: HasAfEnum + ComplexFloating,
 {
-    unsafe {
-        let err_val = af_ifft3_inplace(input.get() as *mut af_array, norm_factor);
-        HANDLE_ERROR(AfError::from(err_val));
-    }
+    let err_val = unsafe { af_ifft3_inplace(input.get() as *mut af_array, norm_factor) };
+    HANDLE_ERROR(AfError::from(err_val));
 }
 
 /// 1d Real to Complex fast fourier transform
@@ -981,12 +959,10 @@ where
     T: HasAfEnum + RealFloating,
     Complex<T>: HasAfEnum,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_fft_r2c(&mut temp as *mut af_array, input.get(), norm_factor, pad0);
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe { af_fft_r2c(&mut temp as *mut af_array, input.get(), norm_factor, pad0) };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// 2d Real to Complex fast fourier transform
@@ -1006,18 +982,18 @@ where
     T: HasAfEnum + RealFloating,
     Complex<T>: HasAfEnum,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_fft2_r2c(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_fft2_r2c(
             &mut temp as *mut af_array,
             input.get(),
             norm_factor,
             pad0,
             pad1,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// 3d Real to Complex fast fourier transform
@@ -1044,19 +1020,19 @@ where
     T: HasAfEnum + RealFloating,
     Complex<T>: HasAfEnum,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_fft3_r2c(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_fft3_r2c(
             &mut temp as *mut af_array,
             input.get(),
             norm_factor,
             pad0,
             pad1,
             pad2,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// 1d Complex to Real fast fourier transform
@@ -1075,12 +1051,11 @@ where
     T: HasAfEnum + ComplexFloating,
     <T as HasAfEnum>::BaseType: HasAfEnum,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_fft_c2r(&mut temp as *mut af_array, input.get(), norm_factor, is_odd);
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val =
+        unsafe { af_fft_c2r(&mut temp as *mut af_array, input.get(), norm_factor, is_odd) };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// 2d Complex to Real fast fourier transform
@@ -1099,12 +1074,11 @@ where
     T: HasAfEnum + ComplexFloating,
     <T as HasAfEnum>::BaseType: HasAfEnum,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_fft2_c2r(&mut temp as *mut af_array, input.get(), norm_factor, is_odd);
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val =
+        unsafe { af_fft2_c2r(&mut temp as *mut af_array, input.get(), norm_factor, is_odd) };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// 3d Complex to Real fast fourier transform
@@ -1123,10 +1097,9 @@ where
     T: HasAfEnum + ComplexFloating,
     <T as HasAfEnum>::BaseType: HasAfEnum,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_fft3_c2r(&mut temp as *mut af_array, input.get(), norm_factor, is_odd);
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val =
+        unsafe { af_fft3_c2r(&mut temp as *mut af_array, input.get(), norm_factor, is_odd) };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
diff --git a/src/sparse/mod.rs b/src/sparse/mod.rs
index edd2d5860..58bf2fc21 100644
--- a/src/sparse/mod.rs
+++ b/src/sparse/mod.rs
@@ -91,9 +91,9 @@ pub fn sparse<T>(
 where
     T: HasAfEnum + FloatingPoint,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_create_sparse_array(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_create_sparse_array(
             &mut temp as *mut af_array,
             rows as dim_t,
             cols as dim_t,
@@ -101,10 +101,10 @@ where
             row_indices.get(),
             col_indices.get(),
             format as c_uint,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Create sprase matrix from data on host memory
@@ -144,9 +144,10 @@ where
     T: HasAfEnum + FloatingPoint,
 {
     let aftype = T::get_af_dtype();
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_create_sparse_array_from_ptr(
+
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_create_sparse_array_from_ptr(
             &mut temp as *mut af_array,
             rows as dim_t,
             cols as dim_t,
@@ -157,10 +158,10 @@ where
             aftype as c_uint,
             format as c_uint,
             1,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Convert dense array to sparse array
@@ -177,16 +178,12 @@ pub fn sparse_from_dense<T>(dense: &Array<T>, format: SparseFormat) -> Array<T>
 where
     T: HasAfEnum + FloatingPoint,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_create_sparse_array_from_dense(
-            &mut temp as *mut af_array,
-            dense.get(),
-            format as c_uint,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_create_sparse_array_from_dense(&mut temp as *mut af_array, dense.get(), format as c_uint)
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Convert between sparse formats
@@ -203,13 +200,11 @@ pub fn sparse_convert_to<T>(input: &Array<T>, format: SparseFormat) -> Array<T>
 where
     T: HasAfEnum + FloatingPoint,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val =
-            af_sparse_convert_to(&mut temp as *mut af_array, input.get(), format as c_uint);
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val =
+        unsafe { af_sparse_convert_to(&mut temp as *mut af_array, input.get(), format as c_uint) };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Convert sparse array to dense array
@@ -225,12 +220,10 @@ pub fn sparse_to_dense<T>(input: &Array<T>) -> Array<T>
 where
     T: HasAfEnum + FloatingPoint,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_sparse_to_dense(&mut temp as *mut af_array, input.get());
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe { af_sparse_to_dense(&mut temp as *mut af_array, input.get()) };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Get sparse Array information
@@ -246,26 +239,26 @@ pub fn sparse_get_info<T>(input: &Array<T>) -> (Array<T>, Array<i32>, Array<i32>
 where
     T: HasAfEnum + FloatingPoint,
 {
-    unsafe {
-        let mut val: af_array = std::ptr::null_mut();
-        let mut row: af_array = std::ptr::null_mut();
-        let mut col: af_array = std::ptr::null_mut();
-        let mut stype: u32 = 0;
-        let err_val = af_sparse_get_info(
+    let mut val: af_array = std::ptr::null_mut();
+    let mut row: af_array = std::ptr::null_mut();
+    let mut col: af_array = std::ptr::null_mut();
+    let mut stype: u32 = 0;
+    let err_val = unsafe {
+        af_sparse_get_info(
             &mut val as *mut af_array,
             &mut row as *mut af_array,
             &mut col as *mut af_array,
             &mut stype as *mut c_uint,
             input.get(),
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        (
-            val.into(),
-            row.into(),
-            col.into(),
-            SparseFormat::from(stype),
         )
-    }
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    (
+        val.into(),
+        row.into(),
+        col.into(),
+        SparseFormat::from(stype),
+    )
 }
 
 /// Get values of sparse Array
@@ -281,12 +274,10 @@ pub fn sparse_get_values<T>(input: &Array<T>) -> Array<T>
 where
     T: HasAfEnum + FloatingPoint,
 {
-    unsafe {
-        let mut val: af_array = std::ptr::null_mut();
-        let err_val = af_sparse_get_values(&mut val as *mut af_array, input.get());
-        HANDLE_ERROR(AfError::from(err_val));
-        val.into()
-    }
+    let mut val: af_array = std::ptr::null_mut();
+    let err_val = unsafe { af_sparse_get_values(&mut val as *mut af_array, input.get()) };
+    HANDLE_ERROR(AfError::from(err_val));
+    val.into()
 }
 
 /// Get row indices Array
@@ -302,12 +293,10 @@ pub fn sparse_get_row_indices<T>(input: &Array<T>) -> Array<i32>
 where
     T: HasAfEnum + FloatingPoint,
 {
-    unsafe {
-        let mut val: af_array = std::ptr::null_mut();
-        let err_val = af_sparse_get_row_idx(&mut val as *mut af_array, input.get());
-        HANDLE_ERROR(AfError::from(err_val));
-        val.into()
-    }
+    let mut val: af_array = std::ptr::null_mut();
+    let err_val = unsafe { af_sparse_get_row_idx(&mut val as *mut af_array, input.get()) };
+    HANDLE_ERROR(AfError::from(err_val));
+    val.into()
 }
 
 /// Get cololumn indices Array
@@ -323,12 +312,10 @@ pub fn sparse_get_col_indices<T>(input: &Array<T>) -> Array<i32>
 where
     T: HasAfEnum + FloatingPoint,
 {
-    unsafe {
-        let mut val: af_array = std::ptr::null_mut();
-        let err_val = af_sparse_get_col_idx(&mut val as *mut af_array, input.get());
-        HANDLE_ERROR(AfError::from(err_val));
-        val.into()
-    }
+    let mut val: af_array = std::ptr::null_mut();
+    let err_val = unsafe { af_sparse_get_col_idx(&mut val as *mut af_array, input.get()) };
+    HANDLE_ERROR(AfError::from(err_val));
+    val.into()
 }
 
 /// Get number of non-zero elements in sparse array
@@ -342,10 +329,10 @@ where
 /// Number of non-zero elements of sparse Array
 pub fn sparse_get_nnz<T: HasAfEnum>(input: &Array<T>) -> i64 {
     let mut count: i64 = 0;
-    unsafe {
-        let err_val = af_sparse_get_nnz(&mut count as *mut dim_t, input.get());
-        HANDLE_ERROR(AfError::from(err_val));
-    }
+
+    let err_val = unsafe { af_sparse_get_nnz(&mut count as *mut dim_t, input.get()) };
+    HANDLE_ERROR(AfError::from(err_val));
+
     count
 }
 
@@ -360,9 +347,9 @@ pub fn sparse_get_nnz<T: HasAfEnum>(input: &Array<T>) -> i64 {
 /// Sparse array format
 pub fn sparse_get_format<T: HasAfEnum>(input: &Array<T>) -> SparseFormat {
     let mut stype: u32 = 0;
-    unsafe {
-        let err_val = af_sparse_get_storage(&mut stype as *mut c_uint, input.get());
-        HANDLE_ERROR(AfError::from(err_val));
-    }
+
+    let err_val = unsafe { af_sparse_get_storage(&mut stype as *mut c_uint, input.get()) };
+    HANDLE_ERROR(AfError::from(err_val));
+
     SparseFormat::from(stype)
 }
diff --git a/src/statistics/mod.rs b/src/statistics/mod.rs
index d79d280d2..97fffd65d 100644
--- a/src/statistics/mod.rs
+++ b/src/statistics/mod.rs
@@ -78,12 +78,10 @@ pub fn median<T>(input: &Array<T>, dim: i64) -> Array<T>
 where
     T: HasAfEnum + MedianComputable,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_median(&mut temp as *mut af_array, input.get(), dim);
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe { af_median(&mut temp as *mut af_array, input.get(), dim) };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 macro_rules! stat_func_def {
@@ -104,12 +102,10 @@ macro_rules! stat_func_def {
             T: HasAfEnum,
             T::MeanOutType: HasAfEnum,
         {
-            unsafe {
-                let mut temp: af_array = std::ptr::null_mut();
-                let err_val = $ffi_fn(&mut temp as *mut af_array, input.get(), dim);
-                HANDLE_ERROR(AfError::from(err_val));
-                temp.into()
-            }
+            let mut temp: af_array = std::ptr::null_mut();
+            let err_val = unsafe { $ffi_fn(&mut temp as *mut af_array, input.get(), dim) };
+            HANDLE_ERROR(AfError::from(err_val));
+            temp.into()
         }
     };
 }
@@ -140,12 +136,11 @@ macro_rules! stat_wtd_func_def {
             T::MeanOutType: HasAfEnum,
             W: HasAfEnum + RealFloating,
         {
-            unsafe {
-                let mut temp: af_array = std::ptr::null_mut();
-                let err_val = $ffi_fn(&mut temp as *mut af_array, input.get(), weights.get(), dim);
-                HANDLE_ERROR(AfError::from(err_val));
-                temp.into()
-            }
+            let mut temp: af_array = std::ptr::null_mut();
+            let err_val =
+                unsafe { $ffi_fn(&mut temp as *mut af_array, input.get(), weights.get(), dim) };
+            HANDLE_ERROR(AfError::from(err_val));
+            temp.into()
         }
     };
 }
@@ -179,17 +174,17 @@ where
     T: HasAfEnum,
     T::MeanOutType: HasAfEnum,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_var_v2(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_var_v2(
             &mut temp as *mut af_array,
             arr.get(),
             bias_kind as c_uint,
             dim,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Compute Variance along a specific dimension
@@ -238,17 +233,17 @@ where
     T: HasAfEnum + CovarianceComputable,
     T::MeanOutType: HasAfEnum,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_cov_v2(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_cov_v2(
             &mut temp as *mut af_array,
             x.get(),
             y.get(),
             bias_kind as c_uint,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Compute covariance of two Arrays
@@ -294,15 +289,17 @@ where
 pub fn var_all_v2<T: HasAfEnum>(input: &Array<T>, bias_kind: VarianceBias) -> (f64, f64) {
     let mut real: f64 = 0.0;
     let mut imag: f64 = 0.0;
-    unsafe {
-        let err_val = af_var_all_v2(
+
+    let err_val = unsafe {
+        af_var_all_v2(
             &mut real as *mut c_double,
             &mut imag as *mut c_double,
             input.get(),
             bias_kind as c_uint,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+
     (real, imag)
 }
 
@@ -342,14 +339,16 @@ macro_rules! stat_all_func_def {
         pub fn $fn_name<T: HasAfEnum>(input: &Array<T>) -> (f64, f64) {
             let mut real: f64 = 0.0;
             let mut imag: f64 = 0.0;
-            unsafe {
-                let err_val = $ffi_fn(
+
+            let err_val = unsafe {
+                $ffi_fn(
                     &mut real as *mut c_double,
                     &mut imag as *mut c_double,
                     input.get(),
-                );
-                HANDLE_ERROR(AfError::from(err_val));
-            }
+                )
+            };
+            HANDLE_ERROR(AfError::from(err_val));
+
             (real, imag)
         }
     };
@@ -372,14 +371,16 @@ where
 {
     let mut real: f64 = 0.0;
     let mut imag: f64 = 0.0;
-    unsafe {
-        let err_val = af_median_all(
+
+    let err_val = unsafe {
+        af_median_all(
             &mut real as *mut c_double,
             &mut imag as *mut c_double,
             input.get(),
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+
     (real, imag)
 }
 
@@ -402,15 +403,17 @@ macro_rules! stat_wtd_all_func_def {
         {
             let mut real: f64 = 0.0;
             let mut imag: f64 = 0.0;
-            unsafe {
-                let err_val = $ffi_fn(
+
+            let err_val = unsafe {
+                $ffi_fn(
                     &mut real as *mut c_double,
                     &mut imag as *mut c_double,
                     input.get(),
                     weights.get(),
-                );
-                HANDLE_ERROR(AfError::from(err_val));
-            }
+                )
+            };
+            HANDLE_ERROR(AfError::from(err_val));
+
             (real, imag)
         }
     };
@@ -442,15 +445,17 @@ where
 {
     let mut real: f64 = 0.0;
     let mut imag: f64 = 0.0;
-    unsafe {
-        let err_val = af_corrcoef(
+
+    let err_val = unsafe {
+        af_corrcoef(
             &mut real as *mut c_double,
             &mut imag as *mut c_double,
             x.get(),
             y.get(),
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+
     (real, imag)
 }
 
@@ -481,20 +486,20 @@ pub fn topk<T>(input: &Array<T>, k: u32, dim: i32, order: TopkFn) -> (Array<T>,
 where
     T: HasAfEnum,
 {
-    unsafe {
-        let mut t0: af_array = std::ptr::null_mut();
-        let mut t1: af_array = std::ptr::null_mut();
-        let err_val = af_topk(
+    let mut t0: af_array = std::ptr::null_mut();
+    let mut t1: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_topk(
             &mut t0 as *mut af_array,
             &mut t1 as *mut af_array,
             input.get(),
             k as c_int,
             dim as c_int,
             order as c_uint,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        (t0.into(), t1.into())
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    (t0.into(), t1.into())
 }
 
 /// Calculate mean and variance in single API call
@@ -524,20 +529,20 @@ where
     T::MeanOutType: HasAfEnum,
     W: HasAfEnum + RealFloating,
 {
-    unsafe {
-        let mut mean: af_array = std::ptr::null_mut();
-        let mut var: af_array = std::ptr::null_mut();
-        let err_val = af_meanvar(
+    let mut mean: af_array = std::ptr::null_mut();
+    let mut var: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_meanvar(
             &mut mean as *mut af_array,
             &mut var as *mut af_array,
             input.get(),
             weights.get(),
             bias as c_uint,
             dim,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        (mean.into(), var.into())
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    (mean.into(), var.into())
 }
 
 /// Standard deviation along given axis
@@ -559,17 +564,17 @@ where
     T: HasAfEnum,
     T::MeanOutType: HasAfEnum,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_stdev_v2(
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_stdev_v2(
             &mut temp as *mut af_array,
             input.get(),
             bias_kind as c_uint,
             dim,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Standard deviation along specified axis
@@ -607,15 +612,17 @@ where
 pub fn stdev_all_v2<T: HasAfEnum>(input: &Array<T>, bias_kind: VarianceBias) -> (f64, f64) {
     let mut real: f64 = 0.0;
     let mut imag: f64 = 0.0;
-    unsafe {
-        let err_val = af_stdev_all_v2(
+
+    let err_val = unsafe {
+        af_stdev_all_v2(
             &mut real as *mut c_double,
             &mut imag as *mut c_double,
             input.get(),
             bias_kind as c_uint,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+
     (real, imag)
 }
 
diff --git a/src/vision/mod.rs b/src/vision/mod.rs
index 671a2e4c5..35be91056 100644
--- a/src/vision/mod.rs
+++ b/src/vision/mod.rs
@@ -134,17 +134,15 @@ macro_rules! feat_func_def {
     ($doc_str: expr, $fn_name: ident, $ffi_name: ident) => {
         #[doc=$doc_str]
         pub fn $fn_name(&self) -> Array<f32> {
-            unsafe {
-                let mut temp: af_array = std::ptr::null_mut();
-                let err_val = $ffi_name(&mut temp as *mut af_array, self.feat);
-                HANDLE_ERROR(AfError::from(err_val));
+            let mut temp: af_array = std::ptr::null_mut();
+            let err_val = unsafe { $ffi_name(&mut temp as *mut af_array, self.feat) };
+            HANDLE_ERROR(AfError::from(err_val));
 
-                let temp_array: Array<f32> = temp.into();
-                let retained = temp_array.clone();
-                mem::forget(temp_array);
+            let temp_array: Array<f32> = temp.into();
+            let retained = temp_array.clone();
+            mem::forget(temp_array);
 
-                retained
-            }
+            retained
         }
     };
 }
@@ -154,24 +152,24 @@ impl Features {
     ///
     /// This object is basically a bunch of Arrays.
     pub fn new(n: u64) -> Self {
-        unsafe {
-            let mut temp: af_features = std::ptr::null_mut();
-            let err_val = af_create_features(&mut temp as *mut af_features, n as dim_t);
-            HANDLE_ERROR(AfError::from(err_val));
-            Self { feat: temp }
-        }
+        let mut temp: af_features = std::ptr::null_mut();
+        let err_val = unsafe { af_create_features(&mut temp as *mut af_features, n as dim_t) };
+        HANDLE_ERROR(AfError::from(err_val));
+        Self { feat: temp }
     }
 
     /// Get total number of features found
     pub fn num_features(&self) -> i64 {
         let mut temp: i64 = 0;
-        unsafe {
-            let err_val = af_get_features_num(
+
+        let err_val = unsafe {
+            af_get_features_num(
                 &mut temp as *mut dim_t,
                 self.feat as *const dim_t as af_features,
-            );
-            HANDLE_ERROR(AfError::from(err_val));
-        }
+            )
+        };
+        HANDLE_ERROR(AfError::from(err_val));
+
         temp
     }
 
@@ -188,21 +186,17 @@ impl Features {
 
 impl Clone for Features {
     fn clone(&self) -> Self {
-        unsafe {
-            let mut temp: af_features = std::ptr::null_mut();
-            let ret_val = af_retain_features(&mut temp as *mut af_features, self.feat);
-            HANDLE_ERROR(AfError::from(ret_val));
-            Self { feat: temp }
-        }
+        let mut temp: af_features = std::ptr::null_mut();
+        let ret_val = unsafe { af_retain_features(&mut temp as *mut af_features, self.feat) };
+        HANDLE_ERROR(AfError::from(ret_val));
+        Self { feat: temp }
     }
 }
 
 impl Drop for Features {
     fn drop(&mut self) {
-        unsafe {
-            let ret_val = af_release_features(self.feat);
-            HANDLE_ERROR(AfError::from(ret_val));
-        }
+        let ret_val = unsafe { af_release_features(self.feat) };
+        HANDLE_ERROR(AfError::from(ret_val));
     }
 }
 
@@ -245,9 +239,9 @@ pub fn fast<T>(
 where
     T: HasAfEnum + ImageFilterType,
 {
-    unsafe {
-        let mut temp: af_features = std::ptr::null_mut();
-        let err_val = af_fast(
+    let mut temp: af_features = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_fast(
             &mut temp as *mut af_features,
             input.get(),
             thr,
@@ -255,10 +249,10 @@ where
             non_max,
             feat_ratio,
             edge,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        Features { feat: temp }
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    Features { feat: temp }
 }
 
 /// Harris corner detector.
@@ -293,9 +287,9 @@ pub fn harris<T>(
 where
     T: HasAfEnum + RealFloating,
 {
-    unsafe {
-        let mut temp: af_features = std::ptr::null_mut();
-        let err_val = af_harris(
+    let mut temp: af_features = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_harris(
             &mut temp as *mut af_features,
             input.get(),
             max_corners,
@@ -303,10 +297,10 @@ where
             sigma,
             block_size,
             k_thr,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        Features { feat: temp }
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    Features { feat: temp }
 }
 
 /// ORB feature descriptor
@@ -342,10 +336,10 @@ pub fn orb<T>(
 where
     T: HasAfEnum + RealFloating,
 {
-    unsafe {
-        let mut f: af_features = std::ptr::null_mut();
-        let mut d: af_array = std::ptr::null_mut();
-        let err_val = af_orb(
+    let mut f: af_features = std::ptr::null_mut();
+    let mut d: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_orb(
             &mut f as *mut af_features,
             &mut d as *mut af_array,
             input.get(),
@@ -354,10 +348,10 @@ where
             scl_fctr,
             levels,
             blur_img,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        (Features { feat: f }, d.into())
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    (Features { feat: f }, d.into())
 }
 
 /// Hamming feature matcher
@@ -402,20 +396,20 @@ where
     T: HasAfEnum + ImageFilterType,
     T::AggregateOutType: HasAfEnum,
 {
-    unsafe {
-        let mut idx: af_array = std::ptr::null_mut();
-        let mut dist: af_array = std::ptr::null_mut();
-        let err_val = af_hamming_matcher(
+    let mut idx: af_array = std::ptr::null_mut();
+    let mut dist: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_hamming_matcher(
             &mut idx as *mut af_array,
             &mut dist as *mut af_array,
             query.get(),
             train.get(),
             dist_dims,
             n_dist,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        (idx.into(), dist.into())
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    (idx.into(), dist.into())
 }
 
 /// Nearest Neighbour.
@@ -461,10 +455,10 @@ where
     T: HasAfEnum + ImageFilterType,
     T::AggregateOutType: HasAfEnum,
 {
-    unsafe {
-        let mut idx: af_array = std::ptr::null_mut();
-        let mut dist: af_array = std::ptr::null_mut();
-        let err_val = af_nearest_neighbour(
+    let mut idx: af_array = std::ptr::null_mut();
+    let mut dist: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_nearest_neighbour(
             &mut idx as *mut af_array,
             &mut dist as *mut af_array,
             query.get(),
@@ -472,10 +466,10 @@ where
             dist_dim,
             n_dist,
             dist_type as c_int,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        (idx.into(), dist.into())
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    (idx.into(), dist.into())
 }
 
 /// Image matching
@@ -505,17 +499,18 @@ where
         MatchType::NCC | MatchType::ZNCC | MatchType::SHD => HANDLE_ERROR(AfError::ERR_ARG),
         _ => (), // Do nothing valid matching type
     };
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_match_template(
+
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_match_template(
             &mut temp as *mut af_array,
             search_img.get(),
             template_img.get(),
             mtype as c_uint,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// SUSAN corner detector.
@@ -568,9 +563,9 @@ pub fn susan<T>(
 where
     T: HasAfEnum + ImageFilterType,
 {
-    unsafe {
-        let mut temp: af_features = std::ptr::null_mut();
-        let err_val = af_susan(
+    let mut temp: af_features = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_susan(
             &mut temp as *mut af_features,
             input.get(),
             radius,
@@ -578,10 +573,10 @@ where
             geom_thr,
             feature_ratio,
             edge,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        Features { feat: temp }
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    Features { feat: temp }
 }
 
 /// Difference of Gaussians.
@@ -603,12 +598,10 @@ where
     T: HasAfEnum + ImageFilterType,
     T::AbsOutType: HasAfEnum,
 {
-    unsafe {
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_dog(&mut temp as *mut af_array, input.get(), radius1, radius2);
-        HANDLE_ERROR(AfError::from(err_val));
-        temp.into()
-    }
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe { af_dog(&mut temp as *mut af_array, input.get(), radius1, radius2) };
+    HANDLE_ERROR(AfError::from(err_val));
+    temp.into()
 }
 
 /// Homography estimation
@@ -655,10 +648,11 @@ where
     OutType: HasAfEnum + RealFloating,
 {
     let otype = OutType::get_af_dtype();
-    unsafe {
-        let mut inliers: i32 = 0;
-        let mut temp: af_array = std::ptr::null_mut();
-        let err_val = af_homography(
+
+    let mut inliers: i32 = 0;
+    let mut temp: af_array = std::ptr::null_mut();
+    let err_val = unsafe {
+        af_homography(
             &mut temp as *mut af_array,
             &mut inliers as *mut c_int,
             x_src.get(),
@@ -669,10 +663,10 @@ where
             inlier_thr,
             iterations,
             otype as c_uint,
-        );
-        HANDLE_ERROR(AfError::from(err_val));
-        (temp.into(), inliers)
-    }
+        )
+    };
+    HANDLE_ERROR(AfError::from(err_val));
+    (temp.into(), inliers)
 }
 
 #[cfg(test)]