chore: add ColorType and a macro for making it

games/src/ataxx/piece.rs

@@ -11,28 +11,16 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::ops;
-
-use crate::interface::representable_type;
 use crate::interface::ColoredPieceType;
 use crate::interface::RepresentableType;
+use crate::interface::{color_type, representable_type};
 
-representable_type!(
+color_type!(
     /// Color represents all the possible colors that an ataxx piece can have,
     /// specifically, Black and White.
-    enum Color: u8 { Black "x", White "o", }
+    enum Color { Black "x", White "o", }
 );
 
-impl ops::Not for Color {
-    type Output = Color;
-
-    /// not implements the not unary operator (!) which switches the current Color
-    /// to its opposite, i.e. [`Color::Black`] to [`Color::White`] and vice versa.
-    fn not(self) -> Self::Output {
-        unsafe { Color::unsafe_from(self as usize ^ 1) }
-    }
-}
-
 representable_type!(
     /// Piece represents the types of pieces in ataxx, namely Piece and Block.
     enum Piece: u8 { Piece "x", Block "■", }

games/src/chess/color.rs

@@ -11,28 +11,16 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::ops;
-
-use crate::interface::representable_type;
 use crate::interface::ColoredPieceType;
 use crate::interface::RepresentableType;
+use crate::interface::{color_type, representable_type};
 
-representable_type!(
+color_type!(
     /// Color represents all the possible colors that an ataxx piece can have,
     /// specifically, Black and White.
-    enum Color: u8 { White "w", Black "b", }
+    enum Color { White "w", Black "b", }
 );
 
-impl ops::Not for Color {
-    type Output = Color;
-
-    /// not implements the not unary operator (!) which switches the current Color
-    /// to its opposite, i.e. [`Color::Black`] to [`Color::White`] and vice versa.
-    fn not(self) -> Self::Output {
-        unsafe { Color::unsafe_from(self as usize ^ 1) }
-    }
-}
-
 representable_type!(
     /// Piece represents the types of pieces in ataxx, namely Piece and Block.
     enum Piece: u8 {

games/src/interface/mod.rs

@@ -73,6 +73,37 @@ pub enum TypeParseError {
     RangeError(String),
 }
 
+macro_rules! color_type {
+    ($(#[doc = $doc:expr])* enum $type:tt {
+        $first:tt $first_repr:expr,
+        $second:tt $second_repr:expr,
+    }) => {
+
+
+        crate::interface::representable_type! {
+            $(#[doc = $doc])*
+            enum $type: u8 {
+                $first $first_repr, $second $second_repr,
+            }
+        }
+
+        impl std::ops::Not for $type {
+            type Output = Self;
+
+            fn not(self) -> Self::Output {
+                unsafe { Self::unsafe_from(self as usize ^ 1) }
+            }
+        }
+
+        impl crate::interface::ColorType for $type {
+            fn first() -> Self {
+                Self::$first
+            }
+        }
+    }
+}
+pub(crate) use color_type;
+
 macro_rules! representable_type {
     ($(#[doc = $doc:expr])* enum $type:tt: $base:tt {
         $($variant:tt $repr:expr,)*

games/src/interface/piece.rs

@@ -7,7 +7,7 @@ use super::RepresentableType;
 pub trait ColoredPieceType: RepresentableType<u8>
 where
     Self::Piece: RepresentableType<u8>,
-    Self::Color: RepresentableType<u8> + Not,
+    Self::Color: ColorType,
 {
     /// The type for the Piece of the ColoredPiece.
     type Piece;
@@ -31,3 +31,7 @@ where
     #[must_use]
     fn color(self) -> Self::Color;
 }
+
+pub trait ColorType: RepresentableType<u8> + Not {
+    fn first() -> Self;
+}

games/src/isolation/piece.rs

@@ -13,26 +13,16 @@
 
 use std::ops;
 
-use crate::interface::representable_type;
 use crate::interface::ColoredPieceType;
 use crate::interface::RepresentableType;
+use crate::interface::{color_type, representable_type};
 
-representable_type!(
+color_type!(
     /// Color represents all the possible colors that an ataxx piece can have,
     /// specifically, Black and White.
-    enum Color: u8 { White "w", Black "b", }
+    enum Color { White "w", Black "b", }
 );
 
-impl ops::Not for Color {
-    type Output = Color;
-
-    /// not implements the not unary operator (!) which switches the current Color
-    /// to its opposite, i.e. [`Color::Black`] to [`Color::White`] and vice versa.
-    fn not(self) -> Self::Output {
-        unsafe { Color::unsafe_from(self as usize ^ 1) }
-    }
-}
-
 representable_type!(
     /// Piece represents the types of pieces in ataxx, namely Piece and Block.
     enum Piece: u8 { Pawn "p", Tile "-", }