Move Unsigned & Signed associated types into Integer trait

Author: ictrobot

crates/utils/src/number.rs

@@ -65,6 +65,11 @@ pub trait Integer:
     + ShrAssign<u32>
     + TryInto<i128>
 {
+    type Unsigned: UnsignedInteger;
+    type Signed: SignedInteger;
+
+    #[must_use]
+    fn abs_diff(self, rhs: Self) -> Self::Unsigned;
     #[must_use]
     fn checked_add(self, rhs: Self) -> Option<Self>;
     #[must_use]
@@ -75,27 +80,22 @@ pub trait Integer:
     fn trailing_ones(self) -> u32;
     #[must_use]
     fn trailing_zeros(self) -> u32;
+    #[must_use]
+    fn unsigned_abs(self) -> Self::Unsigned;
 }
 
 /// Trait implemented by the primitive unsigned integer types.
-pub trait UnsignedInteger: Integer + From<u8> {
-    type Signed: SignedInteger;
-
+pub trait UnsignedInteger: Integer<Unsigned = Self> + From<u8> {
     #[must_use]
     fn wrapping_add_signed(self, rhs: Self::Signed) -> Self;
 }
 
 /// Trait implemented by the primitive signed integer types.
-pub trait SignedInteger: Integer + Signed {
-    type Unsigned: UnsignedInteger;
-
-    #[must_use]
-    fn unsigned_abs(self) -> Self::Unsigned;
-}
+pub trait SignedInteger: Integer<Signed = Self> + Signed {}
 
 macro_rules! number_impl {
-    (uint => $($t:ty: $signed:ty),+) => {
-        $(impl Number for $t {
+    (int => $($u:ty: $s:ty ),+) => {
+        $(impl Number for $u {
             const ZERO: Self = 0;
             const ONE: Self = 1;
             const MIN: Self = Self::MIN;
@@ -112,19 +112,48 @@ macro_rules! number_impl {
             }
         })+
 
-        number_impl! {@common integer => $($t),+}
+        $(impl Integer for $u {
+            type Unsigned = $u;
+            type Signed = $s;
 
-        $(impl UnsignedInteger for $t {
-            type Signed = $signed;
+            #[inline]
+            fn abs_diff(self, rhs: Self) -> Self::Unsigned {
+                self.abs_diff(rhs)
+            }
+            #[inline]
+            fn checked_add(self, rhs: Self) -> Option<Self> {
+                self.checked_add(rhs)
+            }
+            #[inline]
+            fn checked_sub(self, rhs: Self) -> Option<Self> {
+                self.checked_sub(rhs)
+            }
+            #[inline]
+            fn checked_mul(self, rhs: Self) -> Option<Self> {
+                self.checked_mul(rhs)
+            }
+            #[inline]
+            fn trailing_ones(self) -> u32 {
+                self.trailing_ones()
+            }
+            #[inline]
+            fn trailing_zeros(self) -> u32 {
+                self.trailing_zeros()
+            }
+            #[inline]
+            fn unsigned_abs(self) -> Self::Unsigned {
+                self // no-op for unsigned integers
+            }
+        })+
 
+        $(impl UnsignedInteger for $u {
             #[inline]
             fn wrapping_add_signed(self, rhs: Self::Signed) -> Self {
                 self.wrapping_add_signed(rhs)
             }
         })+
-    };
-    (int => $($t:ty: $unsigned:ty ),+) => {
-        $(impl Number for $t {
+
+        $(impl Number for $s {
             const ZERO: Self = 0;
             const ONE: Self = 1;
             const MIN: Self = Self::MIN;
@@ -141,45 +170,18 @@ macro_rules! number_impl {
             }
         })+
 
-        number_impl! {@common integer => $($t),+}
-        number_impl! {@common signed => $($t),+}
-
-        $(impl SignedInteger for $t {
-            type Unsigned = $unsigned;
-
-            #[inline]
-            fn unsigned_abs(self) -> Self::Unsigned {
-                self.unsigned_abs()
-            }
+        $(impl Signed for $s {
+            const MINUS_ONE: Self = -Self::ONE;
         })+
-    };
-    (float => $($t:ty),+) => {
-        $(impl Number for $t {
-            const ZERO: Self = 0.0;
-            const ONE: Self = 1.0;
-            const MIN: Self = Self::NEG_INFINITY;
-            const MAX: Self = Self::INFINITY;
 
-            #[inline]
-            fn abs(self) -> Self {
-                self.abs()
-            }
+        $(impl Integer for $s {
+            type Unsigned = $u;
+            type Signed = $s;
 
             #[inline]
-            fn rem_euclid(self, rhs: Self) -> Self {
-                self.rem_euclid(rhs)
+            fn abs_diff(self, rhs: Self) -> Self::Unsigned {
+                self.abs_diff(rhs)
             }
-        })+
-
-        number_impl! {@common signed => $($t),+}
-    };
-    (@common signed => $($t:ty),+) => {
-        $(impl Signed for $t {
-            const MINUS_ONE: Self = -Self::ONE;
-        })+
-    };
-    (@common integer => $($t:ty),+) => {
-        $(impl Integer for $t {
             #[inline]
             fn checked_add(self, rhs: Self) -> Option<Self> {
                 self.checked_add(rhs)
@@ -200,11 +202,38 @@ macro_rules! number_impl {
             fn trailing_zeros(self) -> u32 {
                 self.trailing_zeros()
             }
+            #[inline]
+            fn unsigned_abs(self) -> Self::Unsigned {
+                self.unsigned_abs()
+            }
         })+
+
+        $(impl SignedInteger for $s {})+
     };
+    (float => $($t:ty),+) => {$(
+        impl Number for $t {
+            const ZERO: Self = 0.0;
+            const ONE: Self = 1.0;
+            const MIN: Self = Self::NEG_INFINITY;
+            const MAX: Self = Self::INFINITY;
+
+            #[inline]
+            fn abs(self) -> Self {
+                self.abs()
+            }
+
+            #[inline]
+            fn rem_euclid(self, rhs: Self) -> Self {
+                self.rem_euclid(rhs)
+            }
+        }
+
+        impl Signed for $t {
+            const MINUS_ONE: Self = -Self::ONE;
+        }
+    )+};
 }
-number_impl! {uint => u8: i8, u16: i16, u32: i32, u64: i64, u128: i128, usize: isize}
-number_impl! {int => i8: u8, i16: u16, i32: u32, i64: u64, i128: u128, isize: usize}
+number_impl! {int => u8: i8, u16: i16, u32: i32, u64: i64, u128: i128, usize: isize}
 number_impl! {float => f32, f64}
 
 /// Checks if the provided unsigned integer `n` is a prime number.

crates/utils/src/point.rs

@@ -23,14 +23,7 @@ macro_rules! point_impl {
             /// Returns the manhattan distance from the origin.
             #[inline]
             #[must_use]
-            pub fn manhattan_distance(self) -> T {
-                T::ZERO $(+ self.$f.abs())+
-            }
-
-            /// Returns the manhattan distance from the origin.
-            #[inline]
-            #[must_use]
-            pub fn manhattan_distance_unsigned(self) -> T::Unsigned
+            pub fn manhattan_distance(self) -> T::Unsigned
             where
                 T: SignedInteger
             {

crates/year2016/src/day01.rs

@@ -37,7 +37,7 @@ impl Day01 {
             pos += dir * i32::from(steps);
         }
 
-        pos.manhattan_distance_unsigned()
+        pos.manhattan_distance()
     }
 
     #[must_use]
@@ -54,7 +54,7 @@ impl Day01 {
             for _ in 0..steps {
                 pos += dir;
                 if !visited.insert(pos) {
-                    return pos.manhattan_distance_unsigned();
+                    return pos.manhattan_distance();
                 }
             }
         }

crates/year2017/src/day20.rs

@@ -40,7 +40,7 @@ impl Day20 {
         self.particles
             .iter()
             .enumerate()
-            .min_by_key(|&(_, p)| p.position_at_time(1_000_000).manhattan_distance_unsigned())
+            .min_by_key(|&(_, p)| p.position_at_time(1_000_000).manhattan_distance())
             .unwrap()
             .0
     }