First thing first, always run your code through the elixir formatter.

The way you are doing it is fine:

    game = Map.put(game, :board, new_board)
    |> Map.put(:whos_turn, rotate_player(who))
    Map.put(game, :game_state, update_game_state(game))

Though more efficiently would probably be (assuming you can write update_game_state to work on the old state):

  defp accept_move(game = %Game{}, who, index, true) do
    %{game |
      board: put_elem(game.board, index, who),
      whos_turn: rotate_player(who),
      game_state: update_game_state(game),
    }
  end

Use not in:

  def check_board({a, b, c, d, e, f, g, h, i}) when nil not in [a, b, c, d, e, f, g, h, u] do
    :draw
  end
  def check_board(no_nils), do: :in_progress

Otherwise there are a few places in code that could be simplified more but I’m a bit busy at moment… ^.^;

A really small note about aliasing… You can use MODULE when aliasing the module.

eg.

defmodule Tictactoe.Game do
  alias __MODULE__
end

Thanks very much @OvermindDL1 @yurko and @kokolegorille !! Great feedback.

I’d drop pattern matching and do something like this in the end

def check_board(board) do
  if Enum.count(board, &(&1 != nil)) == 0 do
    :draw
  else
    :in_progress
  end
end

upd it’d be wrong though since tuples are not enumerable in elixir, sorry for the confusion

You can always Tuple.to_list/1 them, but the pattern matching way is probably a lot more efficient I’d wager, if that even matters.