How to implement different game rules?

Just use different modules for different games. Maybe also create a basic module with @callbacks and use it as a @behaviour on the implementation modules, to define a common interface for them, and ensure they have the functions the base game module calls.

I think that you could dive straight into a project if Elixir was Object-Oriented (Python). The patterns used to design a game using functional programming are different. In my opinion start by studying the basics of Elixir (Syntax + Project organisation using Mix).
Reading this documentation will be a good starting point.
Good luck.

If You like Poker with Elixir, there is an old post about it here https://tokafish.com/playing-poker-with-elixir-part-1/ You might need to adapt for newer version, but the post is nice.

Other games I often saw, Tic Tac Toe, Tetris…

I wrote a little game engine for go here elixir_go | Hex

For a more complete example, there is this video

@AlecHsueh: I don’t exactly know about rules that you need to implement, but here is my idea:

Firstly declare your configuration with some raw data that you will process in game:

config :my_app, table_rules: %{
  omaha: %{}, # here you can describe rules for Omaha
  texas: %{} # here you can describe rules for Texas Hold'em
}
# Note: keep rules in format that you like

Secondly create a GenServer-based module:

defmodule MyApp.TableServer do
  use GenServer

  def card_played(player, card) do
    call_self({:card_played, player, card})
  end

  # rest public server API

  def init(opts) do
    table_name = opts[:table]
    rules = :my_app |> Application.fetch_env!(:table_rules) |> Map.fetch!(table_name)
    {:ok, %{rules: rules, table_name: table_name}}
  end

  def start_link(opts \\ [table: :texas]) do
    GenServer.start_link(__MODULE__, opts, name: __MODULE__)
  end

  defp call_self(request), do: GenServer.call(__MODULE__, request)

  def handle_call({:card_played, player, card}, _from, state = %{rules: rules}) do
    # your code based on table rules (case, cond, if, etc)
    {:reply, :ok, state}
  end

  # other handlers for calls (as in your public server API
end

Finally for each table you need to start a new server like:

alias MyApp.TableServer

TableServer.start_link(table: :config_table_name)

and call your server public API like:

alias MyApp.TableServer

player = %{} # …
card = %{} # …
TableServer.card_played(player, card)

Note: You can also use DynamicSupervisor for your table server processes.

I would take care not to link the game implementation (e.g. :card_played) to a GenServer. You can implement all of the logic with pure modules and functions.

To Spawn, or not to Spawn? by Saša Jurić gives a good overview about when and how to reach for processes and even talks about an implementation of a card game to boot (Blackjack).

This comment:

your code based on table rules (…)

does not mean that you need to write login directly in this place.

I believe that this is easiest example for board games (as far as I remember table in each game have only one event like card played) at same time + time for players in their rounds to think about next move.