diff --git a/src/core/arith.rs b/src/core/arith.rs
index fb7fab4cc..901074597 100644
--- a/src/core/arith.rs
+++ b/src/core/arith.rs
@@ -287,9 +287,8 @@ macro_rules! binary_func {
         ///   - Only one element in `lhs` or `rhs` along a given dimension/axis
         pub fn $fn_name<A, B>(lhs: &Array<A>, rhs: &Array<B>, batch: bool) -> Array<A::Output>
         where
-            A: HasAfEnum + ImplicitPromote<B>,
-            B: HasAfEnum + ImplicitPromote<A>,
-            <A as ImplicitPromote<B>>::Output: HasAfEnum,
+            A: ImplicitPromote<B>,
+            B: ImplicitPromote<A>,
         {
             unsafe {
                 let mut temp: af_array = std::ptr::null_mut();
@@ -378,8 +377,7 @@ pub trait Convertable {
 
 impl<T> Convertable for T
 where
-    T: Clone + HasAfEnum + ConstGenerator<OutType = T>,
-    <T as ConstGenerator>::OutType: HasAfEnum,
+    T: Clone + ConstGenerator<OutType = T>,
 {
     type OutType = T;
 
@@ -400,9 +398,8 @@ macro_rules! overloaded_binary_func {
     ($doc_str: expr, $fn_name: ident, $help_name: ident, $ffi_name: ident) => {
         fn $help_name<A, B>(lhs: &Array<A>, rhs: &Array<B>, batch: bool) -> Array<A::Output>
         where
-            A: HasAfEnum + ImplicitPromote<B>,
-            B: HasAfEnum + ImplicitPromote<A>,
-            <A as ImplicitPromote<B>>::Output: HasAfEnum,
+            A: ImplicitPromote<B>,
+            B: ImplicitPromote<A>,
         {
             unsafe {
                 let mut temp: af_array = std::ptr::null_mut();
@@ -453,10 +450,8 @@ macro_rules! overloaded_binary_func {
         where
             T: Convertable,
             U: Convertable,
-            <T as Convertable>::OutType: HasAfEnum + ImplicitPromote<<U as Convertable>::OutType>,
-            <U as Convertable>::OutType: HasAfEnum + ImplicitPromote<<T as Convertable>::OutType>,
-            <<T as Convertable>::OutType as ImplicitPromote<<U as Convertable>::OutType>>::Output:
-                HasAfEnum,
+            <T as Convertable>::OutType: ImplicitPromote<<U as Convertable>::OutType>,
+            <U as Convertable>::OutType: ImplicitPromote<<T as Convertable>::OutType>,
         {
             let lhs = arg1.convert(); // Convert to Array<T>
             let rhs = arg2.convert(); // Convert to Array<T>
@@ -507,8 +502,8 @@ macro_rules! overloaded_compare_func {
     ($doc_str: expr, $fn_name: ident, $help_name: ident, $ffi_name: ident) => {
         fn $help_name<A, B>(lhs: &Array<A>, rhs: &Array<B>, batch: bool) -> Array<bool>
         where
-            A: HasAfEnum + ImplicitPromote<B>,
-            B: HasAfEnum + ImplicitPromote<A>,
+            A: ImplicitPromote<B>,
+            B: ImplicitPromote<A>,
         {
             unsafe {
                 let mut temp: af_array = std::ptr::null_mut();
@@ -557,8 +552,8 @@ macro_rules! overloaded_compare_func {
         where
             T: Convertable,
             U: Convertable,
-            <T as Convertable>::OutType: HasAfEnum + ImplicitPromote<<U as Convertable>::OutType>,
-            <U as Convertable>::OutType: HasAfEnum + ImplicitPromote<<T as Convertable>::OutType>,
+            <T as Convertable>::OutType: ImplicitPromote<<U as Convertable>::OutType>,
+            <U as Convertable>::OutType: ImplicitPromote<<T as Convertable>::OutType>,
         {
             let lhs = arg1.convert(); // Convert to Array<T>
             let rhs = arg2.convert(); // Convert to Array<T>
@@ -615,9 +610,8 @@ fn clamp_helper<X, Y>(
     batch: bool,
 ) -> Array<<X as ImplicitPromote<Y>>::Output>
 where
-    X: HasAfEnum + ImplicitPromote<Y>,
-    Y: HasAfEnum + ImplicitPromote<X>,
-    <X as ImplicitPromote<Y>>::Output: HasAfEnum,
+    X: ImplicitPromote<Y>,
+    Y: ImplicitPromote<X>,
 {
     unsafe {
         let mut temp: af_array = std::ptr::null_mut();
@@ -667,10 +661,9 @@ pub fn clamp<T, C>(
     batch: bool,
 ) -> Array<<T as ImplicitPromote<<C as Convertable>::OutType>>::Output>
 where
-    T: HasAfEnum + ImplicitPromote<<C as Convertable>::OutType>,
+    T: ImplicitPromote<<C as Convertable>::OutType>,
     C: Convertable,
-    <C as Convertable>::OutType: HasAfEnum + ImplicitPromote<T>,
-    <T as ImplicitPromote<<C as Convertable>::OutType>>::Output: HasAfEnum,
+    <C as Convertable>::OutType: ImplicitPromote<T>,
 {
     let lo = arg1.convert(); // Convert to Array<T>
     let hi = arg2.convert(); // Convert to Array<T>
@@ -697,8 +690,8 @@ macro_rules! arith_rhs_scalar_func {
         // Implement (&Array<T> op_name rust_type)
         impl<'f, T, U> $op_name<U> for &'f Array<T>
         where
-            T: HasAfEnum + ImplicitPromote<U>,
-            U: HasAfEnum + ImplicitPromote<T> + Clone + ConstGenerator<OutType = U>,
+            T: ImplicitPromote<U>,
+            U: ImplicitPromote<T> + Clone + ConstGenerator<OutType = U>,
         {
             type Output = Array<<T as ImplicitPromote<U>>::Output>;
 
@@ -711,8 +704,8 @@ macro_rules! arith_rhs_scalar_func {
         // Implement (Array<T> op_name rust_type)
         impl<T, U> $op_name<U> for Array<T>
         where
-            T: HasAfEnum + ImplicitPromote<U>,
-            U: HasAfEnum + ImplicitPromote<T> + Clone + ConstGenerator<OutType = U>,
+            T: ImplicitPromote<U>,
+            U: ImplicitPromote<T> + Clone + ConstGenerator<OutType = U>,
         {
             type Output = Array<<T as ImplicitPromote<U>>::Output>;
 
@@ -729,8 +722,8 @@ macro_rules! arith_lhs_scalar_func {
         // Implement (rust_type op_name &Array<T>)
         impl<'f, T> $op_name<&'f Array<T>> for $rust_type
         where
-            T: HasAfEnum + ImplicitPromote<$rust_type>,
-            $rust_type: HasAfEnum + ImplicitPromote<T>,
+            T: ImplicitPromote<$rust_type>,
+            $rust_type: ImplicitPromote<T>,
         {
             type Output = Array<<$rust_type as ImplicitPromote<T>>::Output>;
 
@@ -742,8 +735,8 @@ macro_rules! arith_lhs_scalar_func {
         // Implement (rust_type op_name Array<T>)
         impl<T> $op_name<Array<T>> for $rust_type
         where
-            T: HasAfEnum + ImplicitPromote<$rust_type>,
-            $rust_type: HasAfEnum + ImplicitPromote<T>,
+            T: ImplicitPromote<$rust_type>,
+            $rust_type: ImplicitPromote<T>,
         {
             type Output = Array<<$rust_type as ImplicitPromote<T>>::Output>;
 
@@ -782,9 +775,8 @@ macro_rules! arith_func {
     ($op_name:ident, $fn_name:ident, $delegate:ident) => {
         impl<A, B> $op_name<Array<B>> for Array<A>
         where
-            A: HasAfEnum + ImplicitPromote<B>,
-            B: HasAfEnum + ImplicitPromote<A>,
-            <A as ImplicitPromote<B>>::Output: HasAfEnum,
+            A: ImplicitPromote<B>,
+            B: ImplicitPromote<A>,
         {
             type Output = Array<<A as ImplicitPromote<B>>::Output>;
 
@@ -795,9 +787,8 @@ macro_rules! arith_func {
 
         impl<'a, A, B> $op_name<&'a Array<B>> for Array<A>
         where
-            A: HasAfEnum + ImplicitPromote<B>,
-            B: HasAfEnum + ImplicitPromote<A>,
-            <A as ImplicitPromote<B>>::Output: HasAfEnum,
+            A: ImplicitPromote<B>,
+            B: ImplicitPromote<A>,
         {
             type Output = Array<<A as ImplicitPromote<B>>::Output>;
 
@@ -808,9 +799,8 @@ macro_rules! arith_func {
 
         impl<'a, A, B> $op_name<Array<B>> for &'a Array<A>
         where
-            A: HasAfEnum + ImplicitPromote<B>,
-            B: HasAfEnum + ImplicitPromote<A>,
-            <A as ImplicitPromote<B>>::Output: HasAfEnum,
+            A: ImplicitPromote<B>,
+            B: ImplicitPromote<A>,
         {
             type Output = Array<<A as ImplicitPromote<B>>::Output>;
 
@@ -821,9 +811,8 @@ macro_rules! arith_func {
 
         impl<'a, 'b, A, B> $op_name<&'a Array<B>> for &'b Array<A>
         where
-            A: HasAfEnum + ImplicitPromote<B>,
-            B: HasAfEnum + ImplicitPromote<A>,
-            <A as ImplicitPromote<B>>::Output: HasAfEnum,
+            A: ImplicitPromote<B>,
+            B: ImplicitPromote<A>,
         {
             type Output = Array<<A as ImplicitPromote<B>>::Output>;
 
@@ -849,9 +838,8 @@ macro_rules! bitshift_scalar_func {
     ($rust_type: ty, $trait_name: ident, $op_name: ident) => {
         impl<T> $trait_name<$rust_type> for Array<T>
         where
-            T: HasAfEnum + ImplicitPromote<$rust_type>,
-            $rust_type: HasAfEnum + ImplicitPromote<T>,
-            <T as ImplicitPromote<$rust_type>>::Output: HasAfEnum,
+            T: ImplicitPromote<$rust_type>,
+            $rust_type: ImplicitPromote<T>,
         {
             type Output = Array<<T as ImplicitPromote<$rust_type>>::Output>;
 
@@ -862,9 +850,8 @@ macro_rules! bitshift_scalar_func {
         }
         impl<'f, T> $trait_name<$rust_type> for &'f Array<T>
         where
-            T: HasAfEnum + ImplicitPromote<$rust_type>,
-            $rust_type: HasAfEnum + ImplicitPromote<T>,
-            <T as ImplicitPromote<$rust_type>>::Output: HasAfEnum,
+            T: ImplicitPromote<$rust_type>,
+            $rust_type: ImplicitPromote<T>,
         {
             type Output = Array<<T as ImplicitPromote<$rust_type>>::Output>;
 
@@ -900,10 +887,8 @@ mod op_assign {
         ($op_name:ident, $fn_name:ident, $func: ident) => {
             impl<A, B> $op_name<Array<B>> for Array<A>
             where
-                A: HasAfEnum + ImplicitPromote<B>,
-                B: HasAfEnum + ImplicitPromote<A>,
-                <A as ImplicitPromote<B>>::Output: HasAfEnum,
-                <B as ImplicitPromote<A>>::Output: HasAfEnum,
+                A: ImplicitPromote<B>,
+                B: ImplicitPromote<A>,
             {
                 fn $fn_name(&mut self, rhs: Array<B>) {
                     let tmp_seq = Seq::<f32>::default();
@@ -930,10 +915,8 @@ mod op_assign {
         ($rust_type:ty, $trait_name:ident, $op_name:ident, $func:ident) => {
             impl<T> $trait_name<$rust_type> for Array<T>
             where
-                $rust_type: HasAfEnum + ImplicitPromote<T>,
-                T: HasAfEnum
-                    + ImplicitPromote<$rust_type>
-                    + ImplicitPromote<$rust_type, Output = T>,
+                $rust_type: ImplicitPromote<T>,
+                T: ImplicitPromote<$rust_type, Output = T>,
             {
                 fn $op_name(&mut self, rhs: $rust_type) {
                     let mut temp = $func(self, &rhs, false);
@@ -959,10 +942,8 @@ mod op_assign {
         ($op_name:ident, $fn_name:ident, $func: ident) => {
             impl<A, B> $op_name<Array<B>> for Array<A>
             where
-                A: HasAfEnum + ImplicitPromote<B>,
-                B: HasAfEnum + ImplicitPromote<A>,
-                <A as ImplicitPromote<B>>::Output: HasAfEnum,
-                <B as ImplicitPromote<A>>::Output: HasAfEnum,
+                A: ImplicitPromote<B>,
+                B: ImplicitPromote<A>,
             {
                 fn $fn_name(&mut self, rhs: Array<B>) {
                     let tmp_seq = Seq::<f32>::default();
@@ -985,13 +966,9 @@ mod op_assign {
 ///Implement negation trait for Array
 impl<T> Neg for Array<T>
 where
-    T: HasAfEnum + Zero + ConstGenerator,
-    <T as ConstGenerator>::OutType: HasAfEnum,
-    <T as ConstGenerator>::OutType: ImplicitPromote<T>,
-    T: ImplicitPromote<<T as ConstGenerator>::OutType>,
-    <<T as ConstGenerator>::OutType as ImplicitPromote<T>>::Output: HasAfEnum,
+    T: Zero + ConstGenerator<OutType = T>,
 {
-    type Output = Array<<<T as ConstGenerator>::OutType as ImplicitPromote<T>>::Output>;
+    type Output = Array<T>;
 
     fn neg(self) -> Self::Output {
         let cnst = constant(T::zero(), self.dims());
diff --git a/src/core/data.rs b/src/core/data.rs
index dcca7acda..0fa0f0b94 100644
--- a/src/core/data.rs
+++ b/src/core/data.rs
@@ -124,7 +124,7 @@ extern "C" {
 /// - i16
 /// - u16
 ///
-pub trait ConstGenerator {
+pub trait ConstGenerator: HasAfEnum {
     /// The type of Array<T> object returned by generate function
     type OutType: HasAfEnum;
 
@@ -286,9 +286,9 @@ cnst!(u16, 11);
 /// # Return Values
 ///
 /// An Array of given dimensions with constant value
-pub fn constant<G: ConstGenerator>(cnst: G, dims: Dim4) -> Array<G::OutType>
+pub fn constant<T>(cnst: T, dims: Dim4) -> Array<T>
 where
-    G::OutType: HasAfEnum,
+    T: ConstGenerator<OutType = T>,
 {
     cnst.generate(dims)
 }
diff --git a/src/core/util.rs b/src/core/util.rs
index 39cd4e219..f759dca72 100644
--- a/src/core/util.rs
+++ b/src/core/util.rs
@@ -424,7 +424,7 @@ impl From<u32> for RandomEngineType {
 /// This is an internal trait defined and implemented by ArrayFire
 /// create for rust's built-in types to figure out the data type
 /// binary operation's results.
-pub trait ImplicitPromote<RHS> {
+pub trait ImplicitPromote<RHS>: HasAfEnum {
     /// This type alias points to the type of the result obtained
     /// by performing a given binary option on given type and `RHS`.
     type Output: HasAfEnum;
@@ -606,7 +606,7 @@ implicit!(bool, u16       =>       u16);
 implicit!(bool, u8        =>        u8);
 
 ///Trait qualifier to accept either real or complex typed data
-pub trait FloatingPoint {
+pub trait FloatingPoint: HasAfEnum {
     /// Use to check if trait implementor is real number
     fn is_real() -> bool {
         false
@@ -639,19 +639,19 @@ impl FloatingPoint for f32 {
 }
 
 ///Trait qualifier to accept real data(numbers)
-pub trait RealFloating {}
+pub trait RealFloating: HasAfEnum {}
 
 impl RealFloating for f64 {}
 impl RealFloating for f32 {}
 
 ///Trait qualifier to accept complex data(numbers)
-pub trait ComplexFloating {}
+pub trait ComplexFloating: HasAfEnum {}
 
 impl ComplexFloating for c64 {}
 impl ComplexFloating for c32 {}
 
 ///Trait qualifier indicating it can hold real numbers only
-pub trait RealNumber {}
+pub trait RealNumber: HasAfEnum {}
 
 impl RealNumber for f64 {}
 impl RealNumber for f32 {}
@@ -665,7 +665,7 @@ impl RealNumber for u64 {}
 impl RealNumber for i64 {}
 
 ///Trait qualifier for the type of Arrays accepted by scan operations
-pub trait Scanable {}
+pub trait Scanable: HasAfEnum {}
 
 impl Scanable for i32 {}
 impl Scanable for u32 {}
@@ -674,7 +674,7 @@ impl Scanable for i64 {}
 
 /// Trait qualifier for type of Array's that are accepted
 /// by native image load/save functions.
-pub trait ImageNativeType {}
+pub trait ImageNativeType: HasAfEnum {}
 
 impl ImageNativeType for f32 {}
 impl ImageNativeType for u16 {}
@@ -682,7 +682,7 @@ impl ImageNativeType for u8 {}
 
 /// Trait qualifier for type of Array's that are accepted
 /// by image processing functions especially filtering algorithms
-pub trait ImageFilterType {}
+pub trait ImageFilterType: HasAfEnum {}
 
 impl ImageFilterType for f64 {}
 impl ImageFilterType for f32 {}
@@ -696,7 +696,7 @@ impl ImageFilterType for bool {}
 // TODO Rust haven't stabilized trait aliases yet
 /// Trait qualifier for given type indicating conversion capability between
 /// grayscale and RGB triplets of data
-pub trait GrayRGBConvertible {}
+pub trait GrayRGBConvertible: HasAfEnum {}
 
 impl GrayRGBConvertible for f64 {}
 impl GrayRGBConvertible for f32 {}
@@ -708,7 +708,7 @@ impl GrayRGBConvertible for u8 {}
 
 // TODO Rust haven't stabilized trait aliases yet
 /// Trait qualifier for given type indicating computability of Moments
-pub trait MomentsComputable {}
+pub trait MomentsComputable: HasAfEnum {}
 
 impl MomentsComputable for f64 {}
 impl MomentsComputable for f32 {}
@@ -720,7 +720,7 @@ impl MomentsComputable for u8 {}
 
 // TODO Rust haven't stabilized trait aliases yet
 /// Trait qualifier for given type indicating computability of Median
-pub trait MedianComputable {}
+pub trait MedianComputable: HasAfEnum {}
 
 impl MedianComputable for f64 {}
 impl MedianComputable for f32 {}
@@ -733,7 +733,7 @@ impl MedianComputable for u8 {}
 // TODO Rust haven't stabilized trait aliases yet
 /// Trait qualifier for given type indicating if edge calculations such as
 /// derivates etc. can be performed
-pub trait EdgeComputable {}
+pub trait EdgeComputable: HasAfEnum {}
 
 impl EdgeComputable for f64 {}
 impl EdgeComputable for f32 {}
@@ -744,7 +744,7 @@ impl EdgeComputable for u16 {}
 impl EdgeComputable for u8 {}
 
 /// Trait qualifier for given type indicating computability of covariance
-pub trait CovarianceComputable {}
+pub trait CovarianceComputable: HasAfEnum {}
 
 impl CovarianceComputable for f64 {}
 impl CovarianceComputable for f32 {}
@@ -824,7 +824,7 @@ impl Fromf64 for u8   { fn fromf64(value: f64) -> Self { value as Self }}
 impl Fromf64 for bool { fn fromf64(value: f64) -> Self { value > 0.0   }}
 
 ///Trait qualifier for the type of Arrays accepted by scan operations
-pub trait IndexableType {}
+pub trait IndexableType: HasAfEnum {}
 
 impl IndexableType for f64 {}
 impl IndexableType for i64 {}