Elixir GenServer를 순수함수로 리팩터링하는 법

defmodule CounterServer do
  use GenServer

  def start_link(opts) do
    GenServer.start_link(__MODULE__, %{value: 0}, opts)
  end

  def inc(pid, n \\ 1), do: GenServer.call(pid, {:inc, n})
  def get(pid), do: GenServer.call(pid, :get)

  @impl true
  def init(state), do: {:ok, state}

  @impl true
  def handle_call({:inc, n}, _from, state) do
    new_state = %{state | value: state.value + n}
    {:reply, new_state.value, new_state}
  end

  def handle_call(:get, _from, state) do
    {:reply, state.value, state}
  end
end

defmodule Counter.Core do
  @type state :: %{value: integer()}
  @type event :: :get | {:inc, integer()}

  @type effect ::
          {:reply, term()}
          | {:noreply}

  @spec init() :: state()
  def init(), do: %{value: 0}

  @spec apply(state(), event()) :: {state(), [effect()]}
  def apply(state, :get) do
    {state, [{:reply, state.value}]}
  end

  def apply(state, {:inc, n}) when is_integer(n) do
    new_state = %{state | value: state.value + n}
    {new_state, [{:reply, new_state.value}]}
  end
end

defmodule CounterServer do
  use GenServer

  def start_link(opts) do
    GenServer.start_link(__MODULE__, :ok, opts)
  end

  def inc(pid, n \\ 1), do: GenServer.call(pid, {:inc, n})
  def get(pid), do: GenServer.call(pid, :get)

  @impl true
  def init(:ok), do: {:ok, Counter.Core.init()}

  @impl true
  def handle_call(event, _from, state) do
    {new_state, effects} = Counter.Core.apply(state, event)
    run_effects(effects, new_state)
  end

  defp run_effects(effects, state) do
    # 이 예제는 reply 하나만 있다고 가정
    case effects do
      [{:reply, reply}] -> {:reply, reply, state}
      _ -> {:reply, :ok, state}
    end
  end
end

defmodule Orders.Core do
  @type state :: %{
          order_id: String.t(),
          status: :new | :paid | :shipped,
          total: non_neg_integer()
        }

  @type event ::
          {:pay, %{amount: non_neg_integer()}}
          | {:ship, %{tracking: String.t()}}

  @type effect ::
          {:reply, term()}
          | {:persist, map()}
          | {:publish, String.t(), map()}
          | {:schedule, non_neg_integer(), term()}

  def apply(state, {:pay, %{amount: amount}}) when amount == state.total do
    new_state = %{state | status: :paid}

    effects = [
      {:persist, %{order_id: state.order_id, status: :paid}},
      {:publish, "orders.paid", %{order_id: state.order_id}},
      {:reply, :ok}
    ]

    {new_state, effects}
  end

  def apply(state, {:pay, _}) do
    {state, [{:reply, {:error, :invalid_amount}}]}
  end

  def apply(%{status: :paid} = state, {:ship, %{tracking: t}}) do
    new_state = %{state | status: :shipped}

    effects = [
      {:persist, %{order_id: state.order_id, status: :shipped, tracking: t}},
      {:publish, "orders.shipped", %{order_id: state.order_id, tracking: t}},
      {:schedule, 86_400_000, {:check_delivery, state.order_id}},
      {:reply, :ok}
    ]

    {new_state, effects}
  end

  def apply(state, {:ship, _}) do
    {state, [{:reply, {:error, :not_paid}}]}
  end
end

defmodule Orders.Server do
  use GenServer

  def start_link(opts), do: GenServer.start_link(__MODULE__, opts, opts)

  def pay(pid, amount), do: GenServer.call(pid, {:pay, %{amount: amount}})
  def ship(pid, tracking), do: GenServer.call(pid, {:ship, %{tracking: tracking}})

  @impl true
  def init(opts) do
    state = %{
      core: Keyword.fetch!(opts, :core_state),
      deps: Keyword.fetch!(opts, :deps)
    }

    {:ok, state}
  end

  @impl true
  def handle_call(event, _from, %{core: core_state} = state) do
    {new_core, effects} = Orders.Core.apply(core_state, event)
    state = %{state | core: new_core}

    # reply를 포함한 effect들을 실행하고, 최종적으로 GenServer tuple을 반환
    interpret_call_effects(effects, state)
  end

  defp interpret_call_effects(effects, state) do
    {reply, state} = Enum.reduce(effects, {:ok, state}, fn eff, {reply_acc, st} ->
      case eff do
        {:reply, r} -> {r, st}
        other -> {reply_acc, run_effect(other, st)}
      end
    end)

    {:reply, reply, state}
  end

  defp run_effect({:persist, record}, %{deps: deps} = state) do
    deps.repo.save(record)
    state
  end

  defp run_effect({:publish, topic, payload}, %{deps: deps} = state) do
    deps.pubsub.publish(topic, payload)
    state
  end

  defp run_effect({:schedule, ms, msg}, state) do
    Process.send_after(self(), msg, ms)
    state
  end
end

defmodule Orders.CoreTest do
  use ExUnit.Case, async: true

  test "pay succeeds and emits persist + publish" do
    state = %{order_id: "o-1", status: :new, total: 100}

    {new_state, effects} = Orders.Core.apply(state, {:pay, %{amount: 100}})

    assert new_state.status == :paid
    assert {:reply, :ok} in effects
    assert {:persist, %{order_id: "o-1", status: :paid}} in effects
    assert {:publish, "orders.paid", %{order_id: "o-1"}} in effects
  end

  test "ship fails when not paid" do
    state = %{order_id: "o-1", status: :new, total: 100}

    {new_state, effects} = Orders.Core.apply(state, {:ship, %{tracking: "t"}})

    assert new_state == state
    assert effects == [{:reply, {:error, :not_paid}}]
  end
end