Implement parsing of standard algebraic notation

src/starfish.gleam

···
   move.to_long_algebraic_notation(move)
 }
 
-/// Parses a move from long algebraic notation, in the same format as
-/// [`to_long_algebraic_notation`](#to_long_algebraic_notation). Returns an error
-/// if the syntax is invalid or the move is not legal.
-pub fn parse_long_algebraic_notation(
-  string: String,
-  game: Game,
-) -> Result(Move, Nil) {
-  move.from_long_algebraic_notation(string, game)
-}
-
+/// Parses a move from either long algebraic notation, in the same format as
+/// [`to_long_algebraic_notation`](#to_long_algebraic_notation), or from [Standard
+/// Algebraic Notation](https://en.wikipedia.org/wiki/Algebraic_notation_(chess)).
+/// Returns an error if the syntax is invalid or the move is not legal on the
+/// board.
 pub fn parse_move(move: String, game: Game) -> Result(Move, Nil) {
-  todo
+  let legal_moves = legal_moves(game)
+  case move.from_long_algebraic_notation(move, legal_moves) {
+    Ok(move) -> Ok(move)
+    Error(_) -> move.from_standard_algebraic_notation(move, game, legal_moves)
+  }
 }
 
 pub type GameState {

src/starfish/internal/move.gleam

···
 // calculate legal moves for the specific square we need.
 pub fn from_long_algebraic_notation(
   string: String,
-  game: Game,
+  legal_moves: List(Move),
 ) -> Result(Move, Nil) {
   use #(from, string) <- result.try(board.parse_position(string))
   use #(to, string) <- result.try(board.parse_position(string))
···
     "r" | "R" -> Ok(Some(board.Rook))
     _ -> Error(Nil)
   })
-
-  let legal_moves = legal(game)
 
   let valid_moves =
     list.filter(legal_moves, fn(move) {
···
     _ -> Error(Nil)
   }
 }
+
+pub fn from_standard_algebraic_notation(
+  move: String,
+  game: Game,
+  legal_moves: List(Move),
+) -> Result(Move, Nil) {
+  case parse_special_move(move, game, legal_moves) {
+    Illegal -> Error(Nil)
+    Legal(move) -> Ok(move)
+    Invalid -> {
+      let #(piece_kind, move) = case move {
+        "R" <> move -> #(board.Rook, move)
+        "B" <> move -> #(board.Bishop, move)
+        "N" <> move -> #(board.Knight, move)
+        "K" <> move -> #(board.King, move)
+        "Q" <> move -> #(board.Queen, move)
+        _ -> #(board.Pawn, move)
+      }
+
+      // Pawn moves have entirely different syntax than non-pawn moves
+      use <- bool.lazy_guard(piece_kind == board.Pawn, fn() {
+        parse_pawn_move(move, game, legal_moves)
+      })
+
+      // In order to determine which move syntax this is, we need to parse the
+      // first two characters and match on what they are.
+      use #(first, move) <- result.try(parse_move_part(move))
+      use #(second, move) <- result.try(parse_move_part(move))
+
+      use #(from_file, from_rank, capture, to_file, to_rank, move) <- result.try(
+        case first, second {
+          // `xx` is not an allowed move
+          CaptureSpecifier, CaptureSpecifier -> Error(Nil)
+          // We disambiguate the file and it's a capture (e.g. `Baxc6`)
+          File(file), CaptureSpecifier -> {
+            let from_file = Some(file)
+            let from_rank = None
+            let capture = True
+            use #(to_file, move) <- result.try(parse_file(move))
+            use #(to_rank, move) <- result.try(parse_rank(move))
+
+            Ok(#(from_file, from_rank, capture, to_file, to_rank, move))
+          }
+          // We disambiguate the rank and it's a capture (e.g. `R5xc4`)
+          Rank(rank), CaptureSpecifier -> {
+            let from_file = None
+            let from_rank = Some(rank)
+            let capture = True
+            use #(to_file, move) <- result.try(parse_file(move))
+            use #(to_rank, move) <- result.try(parse_rank(move))
+
+            Ok(#(from_file, from_rank, capture, to_file, to_rank, move))
+          }
+          // It's a capture, and we've parsed the file of the destination (e.g.
+          // `Bxa5`)
+          CaptureSpecifier, File(to_file) -> {
+            let from_file = None
+            let from_rank = None
+            let capture = True
+            use #(to_rank, move) <- result.try(parse_rank(move))
+
+            Ok(#(from_file, from_rank, capture, to_file, to_rank, move))
+          }
+          // We disambiguate the file and we've parsed the file of the destination
+          // (e.g. `Qhd4`)
+          File(from_file), File(to_file) -> {
+            let from_file = Some(from_file)
+            let from_rank = None
+            let capture = False
+            use #(to_rank, move) <- result.try(parse_rank(move))
+
+            Ok(#(from_file, from_rank, capture, to_file, to_rank, move))
+          }
+          // We disambiguate the rank and we've parsed the file of the destination
+          // (e.g. `R7d2`)
+          Rank(rank), File(to_file) -> {
+            let from_file = None
+            let from_rank = Some(rank)
+            let capture = False
+            use #(to_rank, move) <- result.try(parse_rank(move))
+
+            Ok(#(from_file, from_rank, capture, to_file, to_rank, move))
+          }
+          // Capture followed by a rank is not allowed, e.g. `Rx1`
+          CaptureSpecifier, Rank(_) -> Error(Nil)
+          // We've parsed the file and rank, and there's no more move to parse,
+          // so we're done. (e.g. `Nf3`)
+          File(file), Rank(rank) if move == "" ->
+            Ok(#(None, None, False, file, rank, move))
+          // We've disambiguated the rank and file, and we still need to parse
+          // the rest of the move. (e.g. `Qh4xe1`)
+          File(from_file), Rank(from_rank) ->
+            case parse_move_part(move) {
+              Ok(#(CaptureSpecifier, move)) -> {
+                let from_file = Some(from_file)
+                let from_rank = Some(from_rank)
+                let capture = True
+                use #(to_file, move) <- result.try(parse_file(move))
+                use #(to_rank, move) <- result.try(parse_rank(move))
+
+                Ok(#(from_file, from_rank, capture, to_file, to_rank, move))
+              }
+              Ok(#(File(to_file), _)) -> {
+                let from_file = Some(from_file)
+                let from_rank = Some(from_rank)
+                let capture = False
+                use #(to_rank, move) <- result.try(parse_rank(move))
+
+                Ok(#(from_file, from_rank, capture, to_file, to_rank, move))
+              }
+              Ok(#(Rank(_), _)) | Error(_) -> Error(Nil)
+            }
+          // Two ranks are not allowed, e.g. `R15`
+          Rank(_), Rank(_) -> Error(Nil)
+        },
+      )
+
+      use <- bool.guard(move != "", Error(Nil))
+
+      let to = board.position(file: to_file, rank: to_rank)
+
+      case get_pieces(game, piece_kind, legal_moves, from_file, from_rank, to) {
+        [from] if capture -> Ok(Capture(from:, to:))
+        [from] -> Ok(Move(from:, to:))
+        // If there is more than one valid move, the notation is ambiguous, and
+        // so we error. If there are no valid moves, we also error.
+        _ -> Error(Nil)
+      }
+    }
+  }
+}
+
+type MovePart {
+  CaptureSpecifier
+  File(Int)
+  Rank(Int)
+}
+
+fn parse_move_part(move: String) -> Result(#(MovePart, String), Nil) {
+  case move {
+    "x" <> move -> Ok(#(CaptureSpecifier, move))
+    _ ->
+      case parse_file(move) {
+        Ok(#(file, move)) -> Ok(#(File(file), move))
+        Error(_) ->
+          case parse_rank(move) {
+            Ok(#(rank, move)) -> Ok(#(Rank(rank), move))
+            Error(Nil) -> Error(Nil)
+          }
+      }
+  }
+}
+
+type SpecialMove {
+  Invalid
+  Illegal
+  Legal(Move)
+}
+
+fn parse_special_move(
+  move: String,
+  game: Game,
+  legal_moves: List(Move),
+) -> SpecialMove {
+  let move = case move {
+    "O-O" | "0-0" if game.to_move == board.White -> Ok(Castle(4, 6))
+    "O-O" | "0-0" -> Ok(Castle(60, 62))
+    "O-O-O" | "0-0-0" if game.to_move == board.White -> Ok(Castle(4, 2))
+    "O-O-O" | "0-0-0" -> Ok(Castle(60, 58))
+    _ -> Error(Nil)
+  }
+  case move {
+    Error(_) -> Invalid
+    Ok(move) ->
+      case list.contains(legal_moves, move) {
+        False -> Illegal
+        True -> Legal(move)
+      }
+  }
+}
+
+fn parse_pawn_move(
+  move: String,
+  game: Game,
+  legal_moves: List(Move),
+) -> Result(Move, Nil) {
+  use #(file, move) <- result.try(parse_file(move))
+
+  use #(from_file, is_capture, to_file, move) <- result.try(case move {
+    "x" <> move ->
+      parse_file(move)
+      |> result.map(fn(pair) {
+        let #(to_file, move) = pair
+        #(Some(file), True, to_file, move)
+      })
+    _ -> Ok(#(None, False, file, move))
+  })
+
+  use #(rank, move) <- result.try(parse_rank(move))
+
+  use promotion <- result.try(case move {
+    "" -> Ok(None)
+    "n" | "N" | "=n" | "=N" -> Ok(Some(board.Knight))
+    "q" | "Q" | "=q" | "=Q" -> Ok(Some(board.Queen))
+    "b" | "B" | "=b" | "=B" -> Ok(Some(board.Bishop))
+    "r" | "R" | "=r" | "=R" -> Ok(Some(board.Rook))
+    _ -> Error(Nil)
+  })
+
+  let to = board.position(file: to_file, rank:)
+
+  case
+    get_pieces(game, board.Pawn, legal_moves, from_file, None, to),
+    promotion
+  {
+    [from], Some(piece) -> Ok(Promotion(from:, to:, piece:))
+    [from], _ if game.en_passant_square == Some(to) -> Ok(EnPassant(from:, to:))
+    [from], _ if is_capture -> Ok(Capture(from:, to:))
+    [from], _ -> Ok(Move(from:, to:))
+    _, _ -> Error(Nil)
+  }
+}
+
+/// Gets the possible destination squares for a move, based on the information
+/// we know.
+fn get_pieces(
+  game: Game,
+  find_piece: board.Piece,
+  legal_moves: List(Move),
+  from_file: option.Option(Int),
+  from_rank: option.Option(Int),
+  to: Int,
+) -> List(Int) {
+  use pieces, position, #(piece, colour) <- dict.fold(game.board, [])
+  let is_valid =
+    colour == game.to_move
+    && piece == find_piece
+    && case from_file {
+      None -> True
+      Some(file) -> file == board.file(position)
+    }
+    && case from_rank {
+      None -> True
+      Some(rank) -> rank == board.rank(position)
+    }
+    && list.any(legal_moves, fn(move) { move.to == to && move.from == position })
+
+  case is_valid {
+    False -> pieces
+    True -> [position, ..pieces]
+  }
+}
+
+fn parse_file(move: String) -> Result(#(Int, String), Nil) {
+  case move {
+    "a" <> move | "A" <> move -> Ok(#(0, move))
+    "b" <> move | "B" <> move -> Ok(#(1, move))
+    "c" <> move | "C" <> move -> Ok(#(2, move))
+    "d" <> move | "D" <> move -> Ok(#(3, move))
+    "e" <> move | "E" <> move -> Ok(#(4, move))
+    "f" <> move | "F" <> move -> Ok(#(5, move))
+    "g" <> move | "G" <> move -> Ok(#(6, move))
+    "h" <> move | "H" <> move -> Ok(#(7, move))
+    _ -> Error(Nil)
+  }
+}
+
+fn parse_rank(move: String) -> Result(#(Int, String), Nil) {
+  case move {
+    "1" <> move -> Ok(#(0, move))
+    "2" <> move -> Ok(#(1, move))
+    "3" <> move -> Ok(#(2, move))
+    "4" <> move -> Ok(#(3, move))
+    "5" <> move -> Ok(#(4, move))
+    "6" <> move -> Ok(#(5, move))
+    "7" <> move -> Ok(#(6, move))
+    "8" <> move -> Ok(#(7, move))
+    _ -> Error(Nil)
+  }
+}

test/starfish_test.gleam

···
 }
 
 pub fn parse_long_algebraic_notation_test() {
-  let assert Ok(move) =
-    starfish.parse_long_algebraic_notation("a2a4", starfish.new())
+  let assert Ok(move) = starfish.parse_move("a2a4", starfish.new())
   assert move == move.Move(from: 8, to: 24)
-  let assert Ok(move) =
-    starfish.parse_long_algebraic_notation("g1f3", starfish.new())
+  let assert Ok(move) = starfish.parse_move("g1f3", starfish.new())
   assert move == move.Move(from: 6, to: 21)
   let assert Ok(move) =
-    starfish.parse_long_algebraic_notation(
+    starfish.parse_move(
       "b8c6",
       starfish.from_fen(
         "rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq - 0 1",
···
     )
   assert move == move.Move(from: 57, to: 42)
   let assert Ok(move) =
-    starfish.parse_long_algebraic_notation(
+    starfish.parse_move(
       "B7b5",
       starfish.from_fen(
         "rnbqkbnr/pppppppp/8/8/P7/8/1PPPPPPP/RNBQKBNR b KQkq - 0 1",
···
     )
   assert move == move.Move(from: 49, to: 33)
   let assert Ok(move) =
-    starfish.parse_long_algebraic_notation(
+    starfish.parse_move(
       "a5b6",
       starfish.from_fen(
         "rnbqkbnr/p1p1pppp/8/Pp1p4/8/8/1PPPPPPP/RNBQKBNR w KQkq b6 0 3",
···
     )
   assert move == move.EnPassant(from: 32, to: 41)
   let assert Ok(move) =
-    starfish.parse_long_algebraic_notation(
+    starfish.parse_move(
       "e1G1",
       starfish.from_fen(
         "rnbqkbnr/pp3ppp/8/2ppp3/4P3/5N2/PPPPBPPP/RNBQK2R w KQkq - 0 4",
···
     )
   assert move == move.Castle(from: 4, to: 6)
   let assert Ok(move) =
-    starfish.parse_long_algebraic_notation(
+    starfish.parse_move(
       "e1c1",
       starfish.from_fen(
         "rnbqkbnr/ppp2ppp/8/3pp3/3P4/2N1B3/PPPQPPPP/R3KBNR w KQkq - 0 5",
···
     )
   assert move == move.Castle(from: 4, to: 2)
   let assert Ok(move) =
-    starfish.parse_long_algebraic_notation(
+    starfish.parse_move(
       "e8g8",
       starfish.from_fen(
         "rnbqk2r/ppppbppp/5n2/4p3/2PPP3/8/PP3PPP/RNBQKBNR b KQkq - 0 4",
···
     )
   assert move == move.Castle(from: 60, to: 62)
   let assert Ok(move) =
-    starfish.parse_long_algebraic_notation(
+    starfish.parse_move(
       "E8C8",
       starfish.from_fen(
         "r3kbnr/pppqpppp/2n1b3/3p4/3PP3/8/PPP2PPP/RNBQKBNR b KQkq - 0 5",
···
     )
   assert move == move.Castle(from: 60, to: 58)
   let assert Ok(move) =
-    starfish.parse_long_algebraic_notation(
+    starfish.parse_move(
       "d7c8q",
       starfish.from_fen(
         "rnbq1bnr/pppPkpp1/4p2p/8/8/8/PPPP1PPP/RNBQKBNR w KQ - 1 5",
···
     )
   assert move == move.Promotion(from: 51, to: 58, piece: board.Queen)
   let assert Ok(move) =
-    starfish.parse_long_algebraic_notation(
+    starfish.parse_move(
       "d2c1N",
       starfish.from_fen(
         "rnbqkbnr/pppp1ppp/8/8/8/4P2P/PPPpKPP1/RNBQ1BNR b kq - 1 5",
···
     )
   assert move == move.Promotion(from: 11, to: 2, piece: board.Knight)
   let assert Ok(move) =
-    starfish.parse_long_algebraic_notation(
+    starfish.parse_move(
       "b7h1",
       starfish.from_fen(
         "rn1qkbnr/pbpppppp/1p6/6P1/8/8/PPPPPP1P/RNBQKBNR b KQkq - 0 3",
···
     )
   assert move == move.Capture(from: 49, to: 7)
 
-  let assert Error(Nil) =
-    starfish.parse_long_algebraic_notation("abcd", starfish.new())
-  let assert Error(Nil) =
-    starfish.parse_long_algebraic_notation("e2e4extra", starfish.new())
-  let assert Error(Nil) =
-    starfish.parse_long_algebraic_notation("e2", starfish.new())
-  let assert Error(Nil) =
-    starfish.parse_long_algebraic_notation("Bxe4", starfish.new())
+  let assert Error(Nil) = starfish.parse_move("abcd", starfish.new())
+  let assert Error(Nil) = starfish.parse_move("e2e4extra", starfish.new())
+  let assert Error(Nil) = starfish.parse_move("a1c8", starfish.new())
+}
+
+pub fn parse_standard_algebraic_notation_test() {
+  let assert Ok(move) = starfish.parse_move("a4", starfish.new())
+  assert move == move.Move(from: 8, to: 24)
+  let assert Ok(move) = starfish.parse_move("Nf3", starfish.new())
+  assert move == move.Move(from: 6, to: 21)
+  let assert Ok(move) =
+    starfish.parse_move(
+      "Nc6",
+      starfish.from_fen(
+        "rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq - 0 1",
+      ),
+    )
+  assert move == move.Move(from: 57, to: 42)
+  let assert Ok(move) =
+    starfish.parse_move(
+      "b5",
+      starfish.from_fen(
+        "rnbqkbnr/pppppppp/8/8/P7/8/1PPPPPPP/RNBQKBNR b KQkq - 0 1",
+      ),
+    )
+  assert move == move.Move(from: 49, to: 33)
+  let assert Ok(move) =
+    starfish.parse_move(
+      "axb6",
+      starfish.from_fen(
+        "rnbqkbnr/p1p1pppp/8/Pp1p4/8/8/1PPPPPPP/RNBQKBNR w KQkq b6 0 3",
+      ),
+    )
+  assert move == move.EnPassant(from: 32, to: 41)
+  let assert Ok(move) =
+    starfish.parse_move(
+      "O-O",
+      starfish.from_fen(
+        "rnbqkbnr/pp3ppp/8/2ppp3/4P3/5N2/PPPPBPPP/RNBQK2R w KQkq - 0 4",
+      ),
+    )
+  assert move == move.Castle(from: 4, to: 6)
+  let assert Ok(move) =
+    starfish.parse_move(
+      "O-O-O",
+      starfish.from_fen(
+        "rnbqkbnr/ppp2ppp/8/3pp3/3P4/2N1B3/PPPQPPPP/R3KBNR w KQkq - 0 5",
+      ),
+    )
+  assert move == move.Castle(from: 4, to: 2)
+  let assert Ok(move) =
+    starfish.parse_move(
+      "O-O",
+      starfish.from_fen(
+        "rnbqk2r/ppppbppp/5n2/4p3/2PPP3/8/PP3PPP/RNBQKBNR b KQkq - 0 4",
+      ),
+    )
+  assert move == move.Castle(from: 60, to: 62)
+  let assert Ok(move) =
+    starfish.parse_move(
+      "0-0-0",
+      starfish.from_fen(
+        "r3kbnr/pppqpppp/2n1b3/3p4/3PP3/8/PPP2PPP/RNBQKBNR b KQkq - 0 5",
+      ),
+    )
+  assert move == move.Castle(from: 60, to: 58)
+  let assert Ok(move) =
+    starfish.parse_move(
+      "c8q",
+      starfish.from_fen(
+        "rnbq1bnr/pppPkpp1/4p2p/8/8/8/PPPP1PPP/RNBQKBNR w KQ - 1 5",
+      ),
+    )
+  assert move == move.Promotion(from: 51, to: 58, piece: board.Queen)
+  let assert Ok(move) =
+    starfish.parse_move(
+      "c1=N",
+      starfish.from_fen(
+        "rnbqkbnr/pppp1ppp/8/8/8/4P2P/PPPpKPP1/RNBQ1BNR b kq - 1 5",
+      ),
+    )
+  assert move == move.Promotion(from: 11, to: 2, piece: board.Knight)
+  let assert Ok(move) =
+    starfish.parse_move(
+      "Bxh1",
+      starfish.from_fen(
+        "rn1qkbnr/pbpppppp/1p6/6P1/8/8/PPPPPP1P/RNBQKBNR b KQkq - 0 3",
+      ),
+    )
+  assert move == move.Capture(from: 49, to: 7)
+  let assert Ok(move) =
+    starfish.parse_move(
+      "Rac4",
+      starfish.from_fen("k7/8/8/8/R4R2/8/8/7K w - - 0 1"),
+    )
+  assert move == move.Move(from: 24, to: 26)
+
+  let assert Ok(move) =
+    starfish.parse_move(
+      "R7c6",
+      starfish.from_fen("k7/2r5/8/8/2r5/8/8/7K b - - 0 1"),
+    )
+  assert move == move.Move(from: 50, to: 42)
+
+  let assert Error(Nil) = starfish.parse_move("e2", starfish.new())
+  let assert Error(Nil) = starfish.parse_move("Bxe4", starfish.new())
+  let assert Error(Nil) = starfish.parse_move("Ndf3", starfish.new())
 }
 
 pub fn state_test() {