vis and less unwraps

Author: Lars-Schumann

src/notation/fen.rs

@@ -32,6 +32,11 @@ struct FenStrings {
 pub enum GameFromFenError {
     NotAscii,
     WrongFieldCount,
+    MalformedBoard(BoardFromFenError),
+    MalformedPlayer(InvalidPlayer),
+    MalformedEnPassantTarget(SquareFromFenError),
+    MalformedFiftyRuleClock(core::num::ParseIntError),
+    MalformedMoveCount(core::num::ParseIntError),
 }
 impl GameStateCore {
     pub fn try_from_fen(fen: &str) -> Result<Self, GameFromFenError> {
@@ -56,18 +61,23 @@ impl GameStateCore {
             full_move_number: fen_parts[5].clone(),
         };
 
-        let board = Board::try_from_fen_repr(fen.piece_placements.as_slice()).unwrap();
+        let board = Board::try_from_fen_repr(fen.piece_placements.as_slice())
+            .map_err(GameFromFenError::MalformedBoard)?;
 
         let fifty_move_rule_clock =
-            FiftyMoveRuleClock::try_from_fen_repr(fen.half_move_clock.as_slice()).unwrap();
+            FiftyMoveRuleClock::try_from_fen_repr(fen.half_move_clock.as_slice())
+                .map_err(GameFromFenError::MalformedFiftyRuleClock)?;
 
         let castling_rights = CastlingRights::from_fen_repr(&fen.castling_availability);
 
-        let active_player = PlayerKind::try_from_fen_repr(fen.active_player.as_slice()).unwrap();
-        let en_passant_target =
-            Square::try_from_fen_repr(fen.en_passant_target_square.as_slice()).unwrap();
-        let full_move_count =
-            FullMoveCount::try_from_fen_repr(fen.full_move_number.as_slice()).unwrap();
+        let active_player = PlayerKind::try_from_fen_repr(fen.active_player.as_slice())
+            .map_err(GameFromFenError::MalformedPlayer)?;
+
+        let en_passant_target = Square::try_from_fen_repr(fen.en_passant_target_square.as_slice())
+            .map_err(GameFromFenError::MalformedEnPassantTarget)?;
+
+        let full_move_count = FullMoveCount::try_from_fen_repr(fen.full_move_number.as_slice())
+            .map_err(GameFromFenError::MalformedMoveCount)?;
 
         Ok(Self {
             board,
@@ -161,7 +171,11 @@ impl FullMoveCount {
     }
 
     fn to_fen_repr(self) -> Vec<AsciiChar> {
-        self.0.to_string().as_ascii().unwrap().to_owned()
+        self.0
+            .to_string()
+            .as_ascii()
+            .expect("digits are ascii")
+            .to_owned()
     }
 }
 
@@ -171,7 +185,11 @@ impl FiftyMoveRuleClock {
     }
 
     fn to_fen_repr(self) -> Vec<AsciiChar> {
-        self.0.to_string().as_ascii().unwrap().to_owned()
+        self.0
+            .to_string()
+            .as_ascii()
+            .expect("digits are ascii")
+            .to_owned()
     }
 }
 
@@ -269,24 +287,20 @@ pub enum BoardFromFenError {
 
 impl Board {
     fn try_from_fen_repr(value: &[AsciiChar]) -> Result<Self, BoardFromFenError> {
-        fn ascii_char_digit_to_int(char: AsciiChar) -> usize {
-            match char as u8 {
-                ..=b'0' => panic!("{char} is an unexpectedly low digit / ascii char"),
-                b'1'..=b'8' => usize::from(u8::from(char) - b'0'),
-                b'9'.. => panic!("{char} is an unexpectedly high digit / ascii char"),
-            }
-        }
         fn fen_row_to_board_row(
             row: &[AsciiChar],
         ) -> Result<[Option<Piece>; 8], BoardFromFenError> {
             let mut out_row: Vec<Option<Piece>> = vec![];
 
             for c in row {
                 match *c as u8 {
-                    b'1'..=b'8' => out_row.extend(vec![None; ascii_char_digit_to_int(*c)]),
+                    b'1'..=b'8' => out_row.extend(vec![None; usize::from(u8::from(*c) - b'0')]),
                     b'P' | b'N' | b'B' | b'R' | b'Q' | b'K' | b'p' | b'n' | b'b' | b'r' | b'q'
                     | b'k' => {
-                        out_row.push(Some(Piece::try_from_fen_repr(*c).unwrap()));
+                        out_row.push(Some(
+                            Piece::try_from_fen_repr(*c)
+                                .expect("these chars are valid Piece reprs"),
+                        ));
                     }
 
                     _ => return Err(BoardFromFenError::IllegalCharacter(*c)),
@@ -311,8 +325,9 @@ impl Board {
         //TODO: un-fuck this
         for square in Square::ALL {
             new_board[Square {
-                col: Col::try_from(u8::from(square.row)).unwrap(),
-                row: Row::try_from(9 - u8::from(square.col)).unwrap(),
+                col: Col::try_from(u8::from(square.row))
+                    .expect("valid row numbers are valid col numbers"),
+                row: Row::try_from(9 - u8::from(square.col)).expect("9 - 1..=8 is in range 1..=8"),
             }] = piece_placements_chunked[square];
         }
 
@@ -332,7 +347,7 @@ impl Board {
                             running_square_count
                                 .to_string()
                                 .as_ascii()
-                                .unwrap()
+                                .expect("digits are ascii")
                                 .to_owned(),
                         ); //as the running count should never exceed 8, this should always be a single digit
                     }
@@ -346,7 +361,7 @@ impl Board {
                         running_square_count
                             .to_string()
                             .as_ascii()
-                            .unwrap()
+                            .expect("digits are ascii")
                             .to_owned(),
                     ); //as the running count should never exceed 8, this should always be a single digit
                 }
@@ -366,7 +381,7 @@ impl Col {
     }
     #[must_use]
     pub(crate) const fn to_fen_repr(self) -> AsciiChar {
-        AsciiChar::from_u8(u8::from(self) + b'a' - 1).unwrap()
+        AsciiChar::from_u8(u8::from(self) + b'a' - 1).expect("a..=h are ascii")
     }
 }
 impl Row {
@@ -375,7 +390,7 @@ impl Row {
     }
     #[must_use]
     pub(crate) const fn to_fen_repr(self) -> AsciiChar {
-        AsciiChar::from_u8(u8::from(self) + b'0').unwrap()
+        AsciiChar::from_u8(u8::from(self) + b'0').expect("0..=8 are ascii")
     }
 }
 
@@ -467,7 +482,7 @@ mod tests {
 
     #[test]
     fn test_player_kind_fens_round_trip() {
-        for player_kind in [PlayerKind::White, PlayerKind::Black] {
+        for player_kind in PlayerKind::ALL {
             println!(
                 "{player_kind:?}: {}",
                 PlayerKind::to_fen_repr(player_kind).as_str()

src/player.rs

@@ -15,6 +15,8 @@ pub enum PlayerKind {
     Black,
 }
 impl PlayerKind {
+    pub const ALL: [Self; 2] = [Self::White, Self::Black];
+
     #[must_use]
     pub const fn opponent(self) -> Self {
         match self {
@@ -24,23 +26,23 @@ impl PlayerKind {
     }
 
     #[must_use]
-    pub const fn pawn_starting_row(self) -> Row {
+    pub(crate) const fn pawn_starting_row(self) -> Row {
         match self {
             Self::White => Row::_2,
             Self::Black => Row::_7,
         }
     }
 
     #[must_use]
-    pub const fn pawn_promotion_row(self) -> Row {
+    pub(crate) const fn pawn_promotion_row(self) -> Row {
         match self {
             Self::White => Row::_8,
             Self::Black => Row::_1,
         }
     }
 
     #[must_use]
-    pub const fn castling_non_check_needed_squares(self, castling_side: CS) -> [Square; 3] {
+    pub(crate) const fn castling_non_check_needed_squares(self, castling_side: CS) -> [Square; 3] {
         match (self, castling_side) {
             (Self::White, CS::Kingside) => [S::E1, S::F1, S::G1],
             (Self::White, CS::Queenside) => [S::E1, S::D1, S::C1],
@@ -50,7 +52,7 @@ impl PlayerKind {
     }
 
     #[must_use]
-    pub fn castling_free_needed_squares(self, castling_side: CS) -> Vec<Square> {
+    pub(crate) fn castling_free_needed_squares(self, castling_side: CS) -> Vec<Square> {
         match (self, castling_side) {
             (Self::White, CS::Kingside) => vec![S::F1, S::G1],
             (Self::White, CS::Queenside) => {
@@ -64,15 +66,15 @@ impl PlayerKind {
     }
 
     #[must_use]
-    pub const fn king_start(&self) -> Square {
+    pub(crate) const fn king_start(self) -> Square {
         match self {
             Self::White => S::E1,
             Self::Black => S::E8,
         }
     }
 
     #[must_use]
-    pub const fn king_castling_target(&self, castling_side: CS) -> Square {
+    pub(crate) const fn king_castling_target(self, castling_side: CS) -> Square {
         match (self, castling_side) {
             (Self::White, CS::Kingside) => S::G1,
             (Self::White, CS::Queenside) => S::C1,
@@ -82,7 +84,7 @@ impl PlayerKind {
     }
 
     #[must_use]
-    pub const fn rook_start(&self, castling_side: CS) -> Square {
+    pub(crate) const fn rook_start(self, castling_side: CS) -> Square {
         match (self, castling_side) {
             (Self::White, CS::Kingside) => S::H1,
             (Self::White, CS::Queenside) => S::A1,
@@ -92,7 +94,7 @@ impl PlayerKind {
     }
 
     #[must_use]
-    pub const fn rook_castling_target(&self, castling_side: CS) -> Square {
+    pub const fn rook_castling_target(self, castling_side: CS) -> Square {
         match (self, castling_side) {
             (Self::White, CS::Kingside) => S::F1,
             (Self::White, CS::Queenside) => S::D1,
@@ -102,15 +104,15 @@ impl PlayerKind {
     }
 
     #[must_use]
-    pub const fn forwards_one_row(&self) -> Offset {
+    pub(crate) const fn forwards_one_row(self) -> Offset {
         match self {
             Self::White => Offset::U,
             Self::Black => Offset::D,
         }
     }
 
     #[must_use]
-    pub const fn backwards_one_row(&self) -> Offset {
+    pub(crate) const fn backwards_one_row(self) -> Offset {
         self.forwards_one_row() * -1
     }
 }