I often need to abstract some common functionality into a separate module. In cases when this functionality requires keeping some state, I use the following pattern: I keep that state under a separate key in the “parent” module state (usually a GenServer), and to simplify the code I pass “parent” state into the functions of common module.

I’ll give a specific example to make the idea clearer. In the example, there is a GenServer module that handles packets coming from a TCP socket, and there is LineReader module that handles aggregating the raw data packets and extracting lines from them.

Here’s the code (I’ve attempted to omit most of irrelevant parts):

defmodule ClientHandler do
  use GenServer

  def init(%{socket: socket}) do
    state = %{
      socket: socket,
      lr_state: LineReader.initial_state(),
    }
    {:ok, state}
  end

  def handle_info({:tcp, _socket, data}, state) do
    state = LineReader.put_packet(state, data)
    {lines, state} = LineReader.recv_lines(state)
    # ... do something with lines
    {:noreply, state}
  end
end

defmodule LineReader do
  def initial_state() do
    %{lines: [], trailing: ""}
  end

  def put_packet(parent_state, packet) do
    lr_state = parent_state.lr_state
    # ... process the new data packet, update lr_state
    %{parent_state | lr_state: lr_state}
  end

  def recv_lines(parent_state) do
    lr_state = parent_state.lr_state
    lines = lr_state.lines
    lr_state = %{lr_state | lines: []}
    {lines, %{parent_state | lr_state: lr_state}}
  end
end

I feel like this code is a little smelly, because it ties into specific field name in parent state. However, it saves a lot of code on the caller’s side and makes the code much cleaner.

Is such approach an anti-pattern? Are there some better alternatives?