From 77f419ad3bf90520f2e55f51a685869aea7e7b29 Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Sun, 28 Jan 2024 10:02:53 -0800
Subject: [PATCH] =?UTF-8?q?[position]=20Rename=20FenError=20=E2=86=92=20To?=
 =?UTF-8?q?FenError?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Add an associated type called Error to the ToFen trait. This mirrors the try_from
any try_into traits.
---
 position/src/fen.rs | 39 ++++++++++++++++++++++++---------------
 1 file changed, 24 insertions(+), 15 deletions(-)

diff --git a/position/src/fen.rs b/position/src/fen.rs
index 26cdd0c..f21de15 100644
--- a/position/src/fen.rs
+++ b/position/src/fen.rs
@@ -5,16 +5,19 @@ use chessfriend_core::{Color, File, Piece, PlacedPiece, Rank, Square};
 use std::fmt::Write;
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub enum FenError {
+pub enum ToFenError {
     FmtError(std::fmt::Error),
 }
 
 pub trait ToFen {
-    fn to_fen(&self) -> Result<String, FenError>;
+    type Error;
+    fn to_fen(&self) -> Result<String, Self::Error>;
 }
 
 impl ToFen for Position {
-    fn to_fen(&self) -> Result<String, FenError> {
+    type Error = ToFenError;
+
+    fn to_fen(&self) -> Result<String, Self::Error> {
         let mut fen_string = String::new();
 
         let mut empty_squares: u8 = 0;
@@ -25,27 +28,27 @@ impl ToFen for Position {
                     Some(piece) => {
                         if empty_squares > 0 {
                             write!(fen_string, "{}", empty_squares)
-                                .map_err(|err| FenError::FmtError(err))?;
+                                .map_err(|err| ToFenError::FmtError(err))?;
                             empty_squares = 0;
                         }
                         write!(fen_string, "{}", piece.to_fen()?)
-                            .map_err(|err| FenError::FmtError(err))?;
+                            .map_err(|err| ToFenError::FmtError(err))?;
                     }
                     None => empty_squares += 1,
                 }
             }
 
             if empty_squares > 0 {
-                write!(fen_string, "{}", empty_squares).map_err(|err| FenError::FmtError(err))?;
+                write!(fen_string, "{}", empty_squares).map_err(|err| ToFenError::FmtError(err))?;
                 empty_squares = 0;
             }
             if rank != &Rank::ONE {
-                write!(fen_string, "/").map_err(|err| FenError::FmtError(err))?;
+                write!(fen_string, "/").map_err(|err| ToFenError::FmtError(err))?;
             }
         }
 
         write!(fen_string, " {}", self.player_to_move().to_fen()?)
-            .map_err(|err| FenError::FmtError(err))?;
+            .map_err(|err| ToFenError::FmtError(err))?;
 
         let castling = [
             (Color::White, Castle::KingSide),
@@ -73,7 +76,7 @@ impl ToFen for Position {
             " {}",
             if castling.len() > 0 { &castling } else { "-" }
         )
-        .map_err(|err| FenError::FmtError(err))?;
+        .map_err(|err| ToFenError::FmtError(err))?;
 
         write!(
             fen_string,
@@ -84,17 +87,19 @@ impl ToFen for Position {
                 "-".to_string()
             }
         )
-        .map_err(|err| FenError::FmtError(err))?;
+        .map_err(|err| ToFenError::FmtError(err))?;
 
-        write!(fen_string, " {}", self.ply_counter()).map_err(|err| FenError::FmtError(err))?;
-        write!(fen_string, " {}", self.move_number()).map_err(|err| FenError::FmtError(err))?;
+        write!(fen_string, " {}", self.ply_counter()).map_err(|err| ToFenError::FmtError(err))?;
+        write!(fen_string, " {}", self.move_number()).map_err(|err| ToFenError::FmtError(err))?;
 
         Ok(fen_string)
     }
 }
 
 impl ToFen for Color {
-    fn to_fen(&self) -> Result<String, FenError> {
+    type Error = ToFenError;
+
+    fn to_fen(&self) -> Result<String, Self::Error> {
         match self {
             Color::White => Ok("w".to_string()),
             Color::Black => Ok("b".to_string()),
@@ -103,7 +108,9 @@ impl ToFen for Color {
 }
 
 impl ToFen for Piece {
-    fn to_fen(&self) -> Result<String, FenError> {
+    type Error = ToFenError;
+
+    fn to_fen(&self) -> Result<String, Self::Error> {
         let ascii: char = self.to_ascii();
         Ok(String::from(match self.color() {
             Color::White => ascii.to_ascii_uppercase(),
@@ -113,7 +120,9 @@ impl ToFen for Piece {
 }
 
 impl ToFen for PlacedPiece {
-    fn to_fen(&self) -> Result<String, FenError> {
+    type Error = ToFenError;
+
+    fn to_fen(&self) -> Result<String, Self::Error> {
         Ok(self.piece().to_fen()?)
     }
 }