Rust Command-line Tic-Tac-Toe

use std::io;
use std::io::Write;

#[derive(PartialEq, Eq, Copy, Clone)]
enum BoardRow {
    One,
    Two,
    Three
}

impl BoardRow {
    fn from_char(c: char) -> Option<BoardRow> {
        match c {
            '1' => Some(BoardRow::One),
            '2' => Some(BoardRow::Two),
            '3' => Some(BoardRow::Three),
            _ => None
        }
    }
}

#[derive(PartialEq, Eq, Copy, Clone)]
enum BoardColumn {
    A,
    B,
    C
}

impl BoardColumn {
    fn from_char(c: char) -> Option<BoardColumn> {
        match c {
            'A' => Some(BoardColumn::A),
            'B' => Some(BoardColumn::B),
            'C' => Some(BoardColumn::C),
            _ => None
        }
    }
}

#[derive(PartialEq, Eq, Copy, Clone)]
struct BoardLocation(BoardRow, BoardColumn);

impl BoardLocation {
    fn parse_from_string(s: &str) -> Option<BoardLocation> {
        let input = &s.to_uppercase();

        let board_rows = input.chars().filter_map(&BoardRow::from_char).collect::<Vec<_>>();
        let board_columns = input.chars().filter_map(&BoardColumn::from_char).collect::<Vec<_>>();

        if board_rows.len() != 1 || board_columns.len() != 1 {
            None
        } else {
            Some(BoardLocation(board_rows[0], board_columns[0]))
        }
    }
}

#[derive(PartialEq, Eq, Copy, Clone)]
enum Player {
    X,
    O
}

#[derive(PartialEq, Eq, Copy, Clone)]
struct Board {
    board: [[Option<Player>; 3]; 3]
}

impl Board {
    fn new() -> Board {
        Board {board: [[None; 3]; 3]}
    }

    fn display(&self) {
        fn print_horizontal_rule() {
            println!("-+-+-+-");
        }

        println!(" |A|B|C");
        print_horizontal_rule();

        let mut row_printed = false;
        let mut vertical_key_row_num = 1;
        for row in self.board.iter() {
            if row_printed {
                print_horizontal_rule();
            }

            print!("{}|", vertical_key_row_num);
            vertical_key_row_num += 1;

            let mut space_printed = false;
            for space in row.iter() {
                if space_printed {
                    print!("|");
                }
                match *space {
                    None => print!(" "),
                    Some(Player::X) => print!("X"),
                    Some(Player::O) => print!("O")
                }
                space_printed = true;
            }
            println!("");

            row_printed = true;
        }
    }

    fn get_winner(&self) -> Option<Player> {
        let winning_space: Option<Player>;
        if self.board[0][0] == self.board[0][1] && self.board[0][1] == self.board[0][2] {
            winning_space = self.board[0][0];
        } else if self.board[1][0] == self.board[1][1] && self.board[1][1] == self.board[1][2] {
            winning_space = self.board[1][0];
        } else if self.board[2][0] == self.board[2][1] && self.board[2][1] == self.board[2][2] {
            winning_space = self.board[2][0];
        } else if self.board[0][0] == self.board[1][0] && self.board[1][0] == self.board[2][0] {
            winning_space = self.board[0][0];
        } else if self.board[0][1] == self.board[1][1] && self.board[1][1] == self.board[2][1] {
            winning_space = self.board[0][1];
        } else if self.board[0][2] == self.board[1][2] && self.board[1][2] == self.board[2][2] {
            winning_space = self.board[0][2];
        } else if self.board[0][0] == self.board[1][1] && self.board[1][1] == self.board[2][2] {
            winning_space = self.board[0][0];
        } else if self.board[0][2] == self.board[1][1] && self.board[1][1] == self.board[2][0] {
            winning_space = self.board[0][2];
        } else {
            winning_space = None;
        }

        winning_space
    }

    fn is_stalemated(&self) -> bool {
        match self.get_winner() {
            Some(_) => false,
            None => {
                for row in self.board.iter() {
                    for cell in row.iter() {
                        if *cell == None {
                            return false
                        }
                    }
                }
                true
            }
        }
    }

    fn make_move(&mut self, player: Player, location: BoardLocation) {
        let BoardLocation(row, column) = location;
        let row_index: usize;
        let column_index: usize;

        match row {
            BoardRow::One => row_index = 0,
            BoardRow::Two => row_index = 1,
            BoardRow::Three => row_index = 2
        }
        match column {
            BoardColumn::A => column_index = 0,
            BoardColumn::B => column_index = 1,
            BoardColumn::C => column_index = 2
        }

        self.board[row_index][column_index] = Some(player);
    }
}

fn main() {
    let mut board = Board::new();
    board.display();

    let mut current_player = Player::X;
    loop {
        match current_player {
            Player::X => print!("X, enter a location: "),
            Player::O => print!("O, enter a location: ")
        }
        io::stdout().flush().unwrap();

        let mut response = String::new();
        match io::stdin().read_line(&mut response) {
            Ok(_) => {
                match BoardLocation::parse_from_string(&response) {
                    Some(location) => {
                        board.make_move(current_player, location);
                        board.display();
                        match board.get_winner() {
                            Some(winning_player) => {
                                match winning_player {
                                    Player::X => println!("X wins!"),
                                    Player::O => println!("O wins!")
                                }
                                break;
                            }
                            None => {
                                if board.is_stalemated() {
                                    println!("Nobody wins!");
                                    break;
                                }
                            }
                        }
                        match current_player {
                            Player::X => current_player = Player::O,
                            Player::O => current_player = Player::X
                        }
                    }
                    None => {
                        println!("That's not a location!");
                    }
                }
            }
            Err(error) => {
                println!("Error: {}", error);
                break;
            }
        }
    }
}