Skip to content

Commit 57cc29e

Browse files
9prady99prady9
committed
Shorten trait bounds in arith, data modules
1 parent 17ca34b commit 57cc29e

File tree

3 files changed

+60
-83
lines changed

3 files changed

+60
-83
lines changed

‎src/core/arith.rs

Lines changed: 43 additions & 66 deletions
Original file line numberDiff line numberDiff line change
@@ -287,9 +287,8 @@ macro_rules! binary_func {
287287
/// - Only one element in `lhs` or `rhs` along a given dimension/axis
288288
pub fn $fn_name<A, B>(lhs: &Array<A>, rhs: &Array<B>, batch: bool) -> Array<A::Output>
289289
where
290-
A: HasAfEnum + ImplicitPromote<B>,
291-
B: HasAfEnum + ImplicitPromote<A>,
292-
<A as ImplicitPromote<B>>::Output: HasAfEnum,
290+
A: ImplicitPromote<B>,
291+
B: ImplicitPromote<A>,
293292
{
294293
unsafe {
295294
let mut temp: af_array = std::ptr::null_mut();
@@ -378,8 +377,7 @@ pub trait Convertable {
378377

379378
impl<T> Convertable for T
380379
where
381-
T: Clone + HasAfEnum + ConstGenerator<OutType = T>,
382-
<T as ConstGenerator>::OutType: HasAfEnum,
380+
T: Clone + ConstGenerator<OutType = T>,
383381
{
384382
type OutType = T;
385383

@@ -400,9 +398,8 @@ macro_rules! overloaded_binary_func {
400398
($doc_str: expr, $fn_name: ident, $help_name: ident, $ffi_name: ident) => {
401399
fn $help_name<A, B>(lhs: &Array<A>, rhs: &Array<B>, batch: bool) -> Array<A::Output>
402400
where
403-
A: HasAfEnum + ImplicitPromote<B>,
404-
B: HasAfEnum + ImplicitPromote<A>,
405-
<A as ImplicitPromote<B>>::Output: HasAfEnum,
401+
A: ImplicitPromote<B>,
402+
B: ImplicitPromote<A>,
406403
{
407404
unsafe {
408405
let mut temp: af_array = std::ptr::null_mut();
@@ -453,10 +450,8 @@ macro_rules! overloaded_binary_func {
453450
where
454451
T: Convertable,
455452
U: Convertable,
456-
<T as Convertable>::OutType: HasAfEnum + ImplicitPromote<<U as Convertable>::OutType>,
457-
<U as Convertable>::OutType: HasAfEnum + ImplicitPromote<<T as Convertable>::OutType>,
458-
<<T as Convertable>::OutType as ImplicitPromote<<U as Convertable>::OutType>>::Output:
459-
HasAfEnum,
453+
<T as Convertable>::OutType: ImplicitPromote<<U as Convertable>::OutType>,
454+
<U as Convertable>::OutType: ImplicitPromote<<T as Convertable>::OutType>,
460455
{
461456
let lhs = arg1.convert(); // Convert to Array<T>
462457
let rhs = arg2.convert(); // Convert to Array<T>
@@ -507,8 +502,8 @@ macro_rules! overloaded_compare_func {
507502
($doc_str: expr, $fn_name: ident, $help_name: ident, $ffi_name: ident) => {
508503
fn $help_name<A, B>(lhs: &Array<A>, rhs: &Array<B>, batch: bool) -> Array<bool>
509504
where
510-
A: HasAfEnum + ImplicitPromote<B>,
511-
B: HasAfEnum + ImplicitPromote<A>,
505+
A: ImplicitPromote<B>,
506+
B: ImplicitPromote<A>,
512507
{
513508
unsafe {
514509
let mut temp: af_array = std::ptr::null_mut();
@@ -557,8 +552,8 @@ macro_rules! overloaded_compare_func {
557552
where
558553
T: Convertable,
559554
U: Convertable,
560-
<T as Convertable>::OutType: HasAfEnum + ImplicitPromote<<U as Convertable>::OutType>,
561-
<U as Convertable>::OutType: HasAfEnum + ImplicitPromote<<T as Convertable>::OutType>,
555+
<T as Convertable>::OutType: ImplicitPromote<<U as Convertable>::OutType>,
556+
<U as Convertable>::OutType: ImplicitPromote<<T as Convertable>::OutType>,
562557
{
563558
let lhs = arg1.convert(); // Convert to Array<T>
564559
let rhs = arg2.convert(); // Convert to Array<T>
@@ -615,9 +610,8 @@ fn clamp_helper<X, Y>(
615610
batch: bool,
616611
) -> Array<<X as ImplicitPromote<Y>>::Output>
617612
where
618-
X: HasAfEnum + ImplicitPromote<Y>,
619-
Y: HasAfEnum + ImplicitPromote<X>,
620-
<X as ImplicitPromote<Y>>::Output: HasAfEnum,
613+
X: ImplicitPromote<Y>,
614+
Y: ImplicitPromote<X>,
621615
{
622616
unsafe {
623617
let mut temp: af_array = std::ptr::null_mut();
@@ -667,10 +661,9 @@ pub fn clamp<T, C>(
667661
batch: bool,
668662
) -> Array<<T as ImplicitPromote<<C as Convertable>::OutType>>::Output>
669663
where
670-
T: HasAfEnum + ImplicitPromote<<C as Convertable>::OutType>,
664+
T: ImplicitPromote<<C as Convertable>::OutType>,
671665
C: Convertable,
672-
<C as Convertable>::OutType: HasAfEnum + ImplicitPromote<T>,
673-
<T as ImplicitPromote<<C as Convertable>::OutType>>::Output: HasAfEnum,
666+
<C as Convertable>::OutType: ImplicitPromote<T>,
674667
{
675668
let lo = arg1.convert(); // Convert to Array<T>
676669
let hi = arg2.convert(); // Convert to Array<T>
@@ -697,8 +690,8 @@ macro_rules! arith_rhs_scalar_func {
697690
// Implement (&Array<T> op_name rust_type)
698691
impl<'f, T, U> $op_name<U> for &'f Array<T>
699692
where
700-
T: HasAfEnum + ImplicitPromote<U>,
701-
U: HasAfEnum + ImplicitPromote<T> + Clone + ConstGenerator<OutType = U>,
693+
T: ImplicitPromote<U>,
694+
U: ImplicitPromote<T> + Clone + ConstGenerator<OutType = U>,
702695
{
703696
type Output = Array<<T as ImplicitPromote<U>>::Output>;
704697

@@ -711,8 +704,8 @@ macro_rules! arith_rhs_scalar_func {
711704
// Implement (Array<T> op_name rust_type)
712705
impl<T, U> $op_name<U> for Array<T>
713706
where
714-
T: HasAfEnum + ImplicitPromote<U>,
715-
U: HasAfEnum + ImplicitPromote<T> + Clone + ConstGenerator<OutType = U>,
707+
T: ImplicitPromote<U>,
708+
U: ImplicitPromote<T> + Clone + ConstGenerator<OutType = U>,
716709
{
717710
type Output = Array<<T as ImplicitPromote<U>>::Output>;
718711

@@ -729,8 +722,8 @@ macro_rules! arith_lhs_scalar_func {
729722
// Implement (rust_type op_name &Array<T>)
730723
impl<'f, T> $op_name<&'f Array<T>> for $rust_type
731724
where
732-
T: HasAfEnum + ImplicitPromote<$rust_type>,
733-
$rust_type: HasAfEnum + ImplicitPromote<T>,
725+
T: ImplicitPromote<$rust_type>,
726+
$rust_type: ImplicitPromote<T>,
734727
{
735728
type Output = Array<<$rust_type as ImplicitPromote<T>>::Output>;
736729

@@ -742,8 +735,8 @@ macro_rules! arith_lhs_scalar_func {
742735
// Implement (rust_type op_name Array<T>)
743736
impl<T> $op_name<Array<T>> for $rust_type
744737
where
745-
T: HasAfEnum + ImplicitPromote<$rust_type>,
746-
$rust_type: HasAfEnum + ImplicitPromote<T>,
738+
T: ImplicitPromote<$rust_type>,
739+
$rust_type: ImplicitPromote<T>,
747740
{
748741
type Output = Array<<$rust_type as ImplicitPromote<T>>::Output>;
749742

@@ -782,9 +775,8 @@ macro_rules! arith_func {
782775
($op_name:ident, $fn_name:ident, $delegate:ident) => {
783776
impl<A, B> $op_name<Array<B>> for Array<A>
784777
where
785-
A: HasAfEnum + ImplicitPromote<B>,
786-
B: HasAfEnum + ImplicitPromote<A>,
787-
<A as ImplicitPromote<B>>::Output: HasAfEnum,
778+
A: ImplicitPromote<B>,
779+
B: ImplicitPromote<A>,
788780
{
789781
type Output = Array<<A as ImplicitPromote<B>>::Output>;
790782

@@ -795,9 +787,8 @@ macro_rules! arith_func {
795787

796788
impl<'a, A, B> $op_name<&'a Array<B>> for Array<A>
797789
where
798-
A: HasAfEnum + ImplicitPromote<B>,
799-
B: HasAfEnum + ImplicitPromote<A>,
800-
<A as ImplicitPromote<B>>::Output: HasAfEnum,
790+
A: ImplicitPromote<B>,
791+
B: ImplicitPromote<A>,
801792
{
802793
type Output = Array<<A as ImplicitPromote<B>>::Output>;
803794

@@ -808,9 +799,8 @@ macro_rules! arith_func {
808799

809800
impl<'a, A, B> $op_name<Array<B>> for &'a Array<A>
810801
where
811-
A: HasAfEnum + ImplicitPromote<B>,
812-
B: HasAfEnum + ImplicitPromote<A>,
813-
<A as ImplicitPromote<B>>::Output: HasAfEnum,
802+
A: ImplicitPromote<B>,
803+
B: ImplicitPromote<A>,
814804
{
815805
type Output = Array<<A as ImplicitPromote<B>>::Output>;
816806

@@ -821,9 +811,8 @@ macro_rules! arith_func {
821811

822812
impl<'a, 'b, A, B> $op_name<&'a Array<B>> for &'b Array<A>
823813
where
824-
A: HasAfEnum + ImplicitPromote<B>,
825-
B: HasAfEnum + ImplicitPromote<A>,
826-
<A as ImplicitPromote<B>>::Output: HasAfEnum,
814+
A: ImplicitPromote<B>,
815+
B: ImplicitPromote<A>,
827816
{
828817
type Output = Array<<A as ImplicitPromote<B>>::Output>;
829818

@@ -849,9 +838,8 @@ macro_rules! bitshift_scalar_func {
849838
($rust_type: ty, $trait_name: ident, $op_name: ident) => {
850839
impl<T> $trait_name<$rust_type> for Array<T>
851840
where
852-
T: HasAfEnum + ImplicitPromote<$rust_type>,
853-
$rust_type: HasAfEnum + ImplicitPromote<T>,
854-
<T as ImplicitPromote<$rust_type>>::Output: HasAfEnum,
841+
T: ImplicitPromote<$rust_type>,
842+
$rust_type: ImplicitPromote<T>,
855843
{
856844
type Output = Array<<T as ImplicitPromote<$rust_type>>::Output>;
857845

@@ -862,9 +850,8 @@ macro_rules! bitshift_scalar_func {
862850
}
863851
impl<'f, T> $trait_name<$rust_type> for &'f Array<T>
864852
where
865-
T: HasAfEnum + ImplicitPromote<$rust_type>,
866-
$rust_type: HasAfEnum + ImplicitPromote<T>,
867-
<T as ImplicitPromote<$rust_type>>::Output: HasAfEnum,
853+
T: ImplicitPromote<$rust_type>,
854+
$rust_type: ImplicitPromote<T>,
868855
{
869856
type Output = Array<<T as ImplicitPromote<$rust_type>>::Output>;
870857

@@ -900,10 +887,8 @@ mod op_assign {
900887
($op_name:ident, $fn_name:ident, $func: ident) => {
901888
impl<A, B> $op_name<Array<B>> for Array<A>
902889
where
903-
A: HasAfEnum + ImplicitPromote<B>,
904-
B: HasAfEnum + ImplicitPromote<A>,
905-
<A as ImplicitPromote<B>>::Output: HasAfEnum,
906-
<B as ImplicitPromote<A>>::Output: HasAfEnum,
890+
A: ImplicitPromote<B>,
891+
B: ImplicitPromote<A>,
907892
{
908893
fn $fn_name(&mut self, rhs: Array<B>) {
909894
let tmp_seq = Seq::<f32>::default();
@@ -930,10 +915,8 @@ mod op_assign {
930915
($rust_type:ty, $trait_name:ident, $op_name:ident, $func:ident) => {
931916
impl<T> $trait_name<$rust_type> for Array<T>
932917
where
933-
$rust_type: HasAfEnum + ImplicitPromote<T>,
934-
T: HasAfEnum
935-
+ ImplicitPromote<$rust_type>
936-
+ ImplicitPromote<$rust_type, Output = T>,
918+
$rust_type: ImplicitPromote<T>,
919+
T: ImplicitPromote<$rust_type, Output = T>,
937920
{
938921
fn $op_name(&mut self, rhs: $rust_type) {
939922
let mut temp = $func(self, &rhs, false);
@@ -959,10 +942,8 @@ mod op_assign {
959942
($op_name:ident, $fn_name:ident, $func: ident) => {
960943
impl<A, B> $op_name<Array<B>> for Array<A>
961944
where
962-
A: HasAfEnum + ImplicitPromote<B>,
963-
B: HasAfEnum + ImplicitPromote<A>,
964-
<A as ImplicitPromote<B>>::Output: HasAfEnum,
965-
<B as ImplicitPromote<A>>::Output: HasAfEnum,
945+
A: ImplicitPromote<B>,
946+
B: ImplicitPromote<A>,
966947
{
967948
fn $fn_name(&mut self, rhs: Array<B>) {
968949
let tmp_seq = Seq::<f32>::default();
@@ -985,13 +966,9 @@ mod op_assign {
985966
///Implement negation trait for Array
986967
impl<T> Neg for Array<T>
987968
where
988-
T: HasAfEnum + Zero + ConstGenerator,
989-
<T as ConstGenerator>::OutType: HasAfEnum,
990-
<T as ConstGenerator>::OutType: ImplicitPromote<T>,
991-
T: ImplicitPromote<<T as ConstGenerator>::OutType>,
992-
<<T as ConstGenerator>::OutType as ImplicitPromote<T>>::Output: HasAfEnum,
969+
T: Zero + ConstGenerator<OutType = T>,
993970
{
994-
type Output = Array<<<T as ConstGenerator>::OutType as ImplicitPromote<T>>::Output>;
971+
type Output = Array<T>;
995972

996973
fn neg(self) -> Self::Output {
997974
let cnst = constant(T::zero(), self.dims());

‎src/core/data.rs

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -124,7 +124,7 @@ extern "C" {
124124
/// - i16
125125
/// - u16
126126
///
127-
pub trait ConstGenerator {
127+
pub trait ConstGenerator: HasAfEnum {
128128
/// The type of Array<T> object returned by generate function
129129
type OutType: HasAfEnum;
130130

@@ -286,9 +286,9 @@ cnst!(u16, 11);
286286
/// # Return Values
287287
///
288288
/// An Array of given dimensions with constant value
289-
pub fn constant<G: ConstGenerator>(cnst: G, dims: Dim4) -> Array<G::OutType>
289+
pub fn constant<T>(cnst: T, dims: Dim4) -> Array<T>
290290
where
291-
G::OutType: HasAfEnum,
291+
T: ConstGenerator<OutType = T>,
292292
{
293293
cnst.generate(dims)
294294
}

0 commit comments

Comments
 (0)