Change `Move` to only represent legal moves

src/starfish.gleam

···
 pub type Game =
   game.Game
 
-/// A single move on the chess board. `Move(Legal)` represents a move which has
-/// been verified to be legal for a particular position. `Move(Valid)` is a move
-/// which is syntactically valid, but is not necessarily legal to play.
-pub type Move(validity) =
-  move.Move(validity)
-
-pub type Legal =
-  move.Legal
-
-pub type Valid =
-  move.Valid
+/// A single legal move on the chess board.
+pub type Move =
+  move.Move
 
 /// The [FEN string](https://en.wikipedia.org/wiki/Forsyth%E2%80%93Edwards_Notation)
 /// representing the initial position of a chess game.
···
 /// the input, meaning if a FEN string is partially incomplete (e.g. missing the
 /// half-move and full-move counters at the end), it will fill it in with the
 /// default values of the starting position.
-/// 
+///
 /// For strict parsing, see [`try_from_fen`](#try_from_fen).
-/// 
+///
 /// ## Examples
-/// 
+///
 /// The following expressions are all equivalent:
-/// 
+///
 /// ```gleam
 /// starfish.new()
 /// starfish.from_fen(starfish.starting_fen)
···
 /// Tries to parse a game from a FEN string, returning an error if it doesn't
 /// follow standard FEN notation. For more lenient parsing, see [`from_fen`](
 /// #from_fen).
-/// 
+///
 /// ## Examples
-/// 
+///
 /// ```gleam
 /// let assert Ok(start_pos) = starfish.try_from_fen(starfish.starting_fen)
 /// assert start_pos == starfish.new()
-/// 
+///
 /// let assert Error(starfish.ExpectedSpaceAfterSegment) =
 ///   starfish.try_from_fen("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR")
 /// ```
···
 }
 
 /// Convert a game into its FEN string representation.
-/// 
+///
 /// ## Examples
-/// 
+///
 /// ```gleam
 /// assert starfish.to_fen(starfish.new()) == starfish.starting_fen
 /// ```
···
   game.to_fen(game)
 }
 
-pub fn legal_moves(game: Game) -> List(Move(Legal)) {
+pub fn legal_moves(game: Game) -> List(Move) {
   move.legal(game)
 }
 
-pub fn search(game: Game, to_depth depth: Int) -> Result(Move(Legal), Nil) {
+pub fn search(game: Game, to_depth depth: Int) -> Result(Move, Nil) {
   search.best_move(game, depth)
 }
 
-pub fn apply_move(game: Game, move: Move(Legal)) -> Game {
+pub fn apply_move(game: Game, move: Move) -> Game {
   move.apply(game, move)
 }
 
-pub fn to_standard_algebraic_notation(move: Move(a)) -> String {
+pub fn to_standard_algebraic_notation(move: Move) -> String {
   todo
 }
 
···
 /// https://en.wikipedia.org/wiki/Algebraic_notation_(chess)#Long_algebraic_notation),
 /// specifically the UCI format, containing the start and end positions. For
 /// example, `e2e4` or `c7d8q`.
-pub fn to_long_algebraic_notation(move: Move(a)) -> String {
+pub fn to_long_algebraic_notation(move: Move) -> String {
   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).
-pub fn parse_long_algebraic_notation(string: String) -> Result(Move(Valid), Nil) {
-  move.from_long_algebraic_notation(string)
+/// [`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)
 }
 
-pub fn parse_move(move: String, game: Game) -> Result(Move(Valid), Nil) {
-  todo
-}
-
-pub fn parse_legal_move(string: String, game: Game) -> Result(Move(Legal), Nil) {
-  string |> parse_long_algebraic_notation |> result.try(validate_move(_, game))
-}
-
-pub fn validate_move(move: Move(a), game: Game) -> Result(Move(Legal), Nil) {
+pub fn parse_move(move: String, game: Game) -> Result(Move, Nil) {
   todo
 }
 

src/starfish/internal/evaluate.gleam

···
 
 /// Statically evaluates a position. Does not take into account checkmate or
 /// stalemate, those must be accounted for beforehand.
-pub fn evaluate(
-  game: game.Game,
-  legal_moves: List(move.Move(move.Legal)),
-) -> Int {
+pub fn evaluate(game: game.Game, legal_moves: List(move.Move)) -> Int {
   evaluate_position(game) + list.length(legal_moves)
 }
 

src/starfish/internal/move.gleam

···
 import starfish/internal/move/attack
 import starfish/internal/move/direction.{type Direction}
 
-pub type Valid
-
-pub type Legal
-
-pub type Move(validity) {
+pub type Move {
   Castle(from: Int, to: Int)
   Move(from: Int, to: Int)
   Capture(from: Int, to: Int)
···
   Promotion(from: Int, to: Int, piece: board.Piece)
 }
 
-pub fn legal(game: Game) -> List(Move(Legal)) {
+pub fn legal(game: Game) -> List(Move) {
   use moves, position, #(piece, colour) <- dict.fold(game.board, [])
 
   case colour == game.to_move {
···
   game: Game,
   position: Int,
   piece: board.Piece,
-  moves: List(Move(Legal)),
-) -> List(Move(Legal)) {
+  moves: List(Move),
+) -> List(Move) {
   case piece {
     board.Bishop ->
       sliding_moves(game, position, moves, direction.bishop_directions)
···
   }
 }
 
-fn pawn_moves(
-  game: Game,
-  position: Int,
-  moves: List(Move(Legal)),
-) -> List(Move(Legal)) {
+fn pawn_moves(game: Game, position: Int, moves: List(Move)) -> List(Move) {
   let #(forward, left, right, promotion_rank) = case game.to_move {
     board.Black -> #(
       direction.down,
···
 /// En passant needs to be checked slightly different to other moves. For example,
 /// if a row of the board looks something like this, after the black pawn having
 /// moved two squares:
-/// 
+///
 /// ```txt
 /// | K |   | p | P |   |   | r |   |
 /// ```
-/// 
+///
 /// Here, the white pawn is not pinned by the black rook, so it can safely move
 /// forwards. However, if it were to perform en passant and capture the black
 /// pawn, the king would be in check. Here, we check for this case.
-/// 
+///
 /// To perform the check, we cast out rays on either side of the en passant pair.
 /// If we hit the king, as well as a rook or a queen of the opposite colour, then
 /// en passant is not valid.
-/// 
+///
 fn in_check_after_en_passant(
   game: Game,
   position: Int,
···
 fn add_promotions(
   from: Int,
   to: Int,
-  moves: List(Move(Legal)),
+  moves: List(Move),
   pieces: List(board.Piece),
-) -> List(Move(Legal)) {
+) -> List(Move) {
   case pieces {
     [] -> moves
     [piece, ..pieces] ->
···
 fn knight_moves(
   game: Game,
   position: Int,
-  moves: List(Move(Legal)),
+  moves: List(Move),
   directions: List(Direction),
-) -> List(Move(Legal)) {
+) -> List(Move) {
   case directions {
     [] -> moves
     [direction, ..directions] -> {
···
 fn king_moves(
   game: Game,
   position: Int,
-  moves: List(Move(Legal)),
+  moves: List(Move),
   directions: List(Direction),
-) -> List(Move(Legal)) {
+) -> List(Move) {
   let moves = regular_king_moves(game, position, moves, directions)
 
   // If we're in check, castling is not valid.
···
 fn regular_king_moves(
   game: Game,
   position: Int,
-  moves: List(Move(Legal)),
+  moves: List(Move),
   directions: List(Direction),
-) -> List(Move(Legal)) {
+) -> List(Move) {
   case directions {
     [] -> moves
     [direction, ..directions] -> {
···
 fn sliding_moves(
   game: Game,
   position: Int,
-  moves: List(Move(Legal)),
+  moves: List(Move),
   directions: List(Direction),
-) -> List(Move(Legal)) {
+) -> List(Move) {
   case directions {
     [] -> moves
     [direction, ..directions] ->
···
   start_position: Int,
   position: Int,
   direction: Direction,
-  moves: List(Move(Legal)),
-) -> List(Move(Legal)) {
+  moves: List(Move),
+) -> List(Move) {
   let new_position = direction.in_direction(position, direction)
   case board.get(game.board, new_position) {
     board.Empty ->
···
   }
 }
 
-pub fn apply(game: Game, move: Move(Legal)) -> game.Game {
+pub fn apply(game: Game, move: Move) -> game.Game {
   case move {
     Capture(from:, to:) -> do_apply(game, from, to, False, None, True)
     Castle(from:, to:) -> apply_castle(game, from, to, board.file(to) == 2)
···
   }
 }
 
-pub fn to_long_algebraic_notation(move: Move(a)) -> String {
+pub fn to_long_algebraic_notation(move: Move) -> String {
   let from = board.position_to_string(move.from)
   let to = board.position_to_string(move.to)
   let extra = case move {
···
   from <> to <> extra
 }
 
-pub fn from_long_algebraic_notation(string: String) -> Result(Move(Valid), Nil) {
+// TODO: can we do this without calculating every legal move? We can probably just
+// calculate legal moves for the specific square we need.
+pub fn from_long_algebraic_notation(
+  string: String,
+  game: Game,
+) -> Result(Move, Nil) {
   use #(from, string) <- result.try(board.parse_position(string))
   use #(to, string) <- result.try(board.parse_position(string))
-  case string {
-    "" -> Ok(Move(from:, to:))
-    "b" | "B" -> Ok(Promotion(from:, to:, piece: board.Bishop))
-    "n" | "N" -> Ok(Promotion(from:, to:, piece: board.Knight))
-    "q" | "Q" -> Ok(Promotion(from:, to:, piece: board.Queen))
-    "r" | "R" -> Ok(Promotion(from:, to:, piece: board.Rook))
+  use promotion_piece <- result.try(case string {
+    "" -> Ok(None)
+    "b" | "B" -> Ok(Some(board.Bishop))
+    "n" | "N" -> Ok(Some(board.Knight))
+    "q" | "Q" -> Ok(Some(board.Queen))
+    "r" | "R" -> Ok(Some(board.Rook))
+    _ -> Error(Nil)
+  })
+
+  let legal_moves = legal(game)
+
+  let valid_moves =
+    list.filter(legal_moves, fn(move) {
+      move.from == from
+      && move.to == to
+      && case move, promotion_piece {
+        Promotion(..), None -> False
+        Promotion(piece:, ..), Some(promotion) -> piece == promotion
+        _, _ -> promotion_piece == None
+      }
+    })
+
+  case valid_moves {
+    [move] -> Ok(move)
     _ -> Error(Nil)
   }
 }

src/starfish/internal/move/attack.gleam

···
 /// When the king is in check, it cannot move into any squares that are attacked
 /// by other pieces. However, there's another case too. Imagine one row of the
 /// board looks like this:
-/// 
+///
 /// ```txt
 /// | R |   |   |   | k | B |   |   |
 /// ```
-/// 
+///
 /// Here, the white bishop isn't protected by the rook. However, if the king were
 /// to capture the bishop, the rook now is attacking that square, so the king is
 /// still in check. For this reason, we need to calculate all the squares just
-/// past the king in a check line, and prevent the king from moving there. 
+/// past the king in a check line, and prevent the king from moving there.
 fn get_check_attack_squares(
   board: Board,
   attacking: board.Colour,

src/starfish/internal/search.gleam

···
 import starfish/internal/evaluate
 import starfish/internal/game.{type Game}
 import starfish/internal/hash
-import starfish/internal/move
+import starfish/internal/move.{type Move}
 
-/// Not really infinity, but a high enough number that nothing but explicit 
+/// Not really infinity, but a high enough number that nothing but explicit
 /// references to it will reach it.
 const infinity = 1_000_000_000
 
 const checkmate = -1_000_000
-
-type Move =
-  move.Move(move.Legal)
 
 pub fn best_move(game: Game, depth: Int) -> Result(Move, Nil) {
   use <- bool.guard(depth < 1, Error(Nil))

test/starfish_test.gleam

···
 }
 
 pub fn parse_long_algebraic_notation_test() {
-  let assert Ok(move) = starfish.parse_long_algebraic_notation("a2a4")
+  let assert Ok(move) =
+    starfish.parse_long_algebraic_notation("a2a4", starfish.new())
   assert move == move.Move(from: 8, to: 24)
-  let assert Ok(move) = starfish.parse_long_algebraic_notation("g1f3")
+  let assert Ok(move) =
+    starfish.parse_long_algebraic_notation("g1f3", starfish.new())
   assert move == move.Move(from: 6, to: 21)
-  let assert Ok(move) = starfish.parse_long_algebraic_notation("b8c6")
+  let assert Ok(move) =
+    starfish.parse_long_algebraic_notation(
+      "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("B7b5")
+  let assert Ok(move) =
+    starfish.parse_long_algebraic_notation(
+      "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("a5b6")
-  assert move == move.Move(from: 32, to: 41)
-  let assert Ok(move) = starfish.parse_long_algebraic_notation("e1G1")
-  assert move == move.Move(from: 4, to: 6)
-  let assert Ok(move) = starfish.parse_long_algebraic_notation("e1c1")
-  assert move == move.Move(from: 4, to: 2)
-  let assert Ok(move) = starfish.parse_long_algebraic_notation("e8g8")
-  assert move == move.Move(from: 60, to: 62)
-  let assert Ok(move) = starfish.parse_long_algebraic_notation("E8C8")
-  assert move == move.Move(from: 60, to: 58)
-  let assert Ok(move) = starfish.parse_long_algebraic_notation("d7c8q")
+  let assert Ok(move) =
+    starfish.parse_long_algebraic_notation(
+      "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(
+      "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(
+      "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(
+      "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(
+      "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(
+      "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("d2c1N")
+  let assert Ok(move) =
+    starfish.parse_long_algebraic_notation(
+      "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("b7h1")
-  assert move == move.Move(from: 49, to: 7)
+  let assert Ok(move) =
+    starfish.parse_long_algebraic_notation(
+      "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")
-  let assert Error(Nil) = starfish.parse_long_algebraic_notation("e2e4extra")
-  let assert Error(Nil) = starfish.parse_long_algebraic_notation("e2")
-  let assert Error(Nil) = starfish.parse_long_algebraic_notation("Bxe4")
+  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())
 }
 
 pub fn state_test() {
···
 
 fn test_apply_move(
   starting_fen: String,
-  moves: List(move.Move(move.Legal)),
+  moves: List(move.Move),
   expected_fen: String,
 ) {
   let final_fen =