Also check out gen_statem - it’s an example of an abstraction on top of the GenServer behavior that abstracts away state-updating and event routing.

I wrote a library to do this recently -

I didn’t like how it turned out so I never pushed forward - but you might find some value in the source code

If you want a gen_statem that looks like genserver, I wrote https://hexdocs.pm/state_server/StateServer.html

I joined the Elixir Forum just over a week ago, and already I can say the Elixir community is one of the best! Thanks for all the suggestions, going to accept @lucaong 's answer, but they’ve all helped answer my question.

I’m excited to keep learning - just got a client wanting a data ETL pipeline, that is going to be the perfect match for the Elixir/Phoenix ecosystem, GenServer, GenStage, all the rest. First opportunity to use Elixir in production

After refactoring to use behaviours:

A model is defined.

defmodule Marbles do
  @behaviour Cadex.Behaviour

  @initial_conditions %{
    box_A: 11,
    box_B: 0
  }

  @partial_state_update_blocks [
    %Cadex.Types.PartialStateUpdateBlock{
      policies: [
        :robot_1,
        :robot_2
      ],
      variables: [
        :box_A,
        :box_B
      ]
    }
  ]

  @simulation_parameters %Cadex.Types.SimulationParameters{
    T: 10
  }

  @impl true
  def config do
    %Cadex.Types.State{
      sim: %{
        simulation_parameters: @simulation_parameters,
        partial_state_update_blocks: @partial_state_update_blocks
      },
      current: @initial_conditions
    }
  end

  @impl true
  def update(var = :box_A, _state = %Cadex.Types.State{current: current}) do
    increment =
      &(&1 +
          cond do
            current[var] > current[:box_B] -> -1
            current[var] < current[:box_B] -> 1
            true -> 0
          end)

    {:ok, increment}
  end

  @impl true
  def update(var = :box_B, _state = %Cadex.Types.State{current: current}) do
    increment =
      &(&1 +
          cond do
            current[var] > current[:box_A] -> -1
            current[var] < current[:box_A] -> 1
            true -> 0
          end)

    {:ok, increment}
  end
end

The model is run (down the line there will be settings for Monte carlo simulations etc.)

{:ok, pid} = Cadex.start(Marbles)
Cadex.update(:box_A)
Cadex.update(:box_B)
state = Cadex.state()

# Or, to run a full model loop
Cadex.run(optional_args)

This looks much better.