Hey! Large modules can definitely be a pain, but this is not the way to solve them. Find boundaries, break those things out into dedicated modules, then just have them each call each other.

@benwilson512 thanks for your input - and although I will probably end up doing that, I still think the error should be shown from its line on the used module and not the line where the use statement is (not sure how difficult it is to achieve in technical terms…).

Thanks @ericmj - that indeed answers my question. I will nonetheless try organising my code in a different way, following ben’s and your advice - in my head - probably wrong - those functions would belong together in the same module, perhaps except messages and create, since they are all operations on the game state (but I will probably curse the future me about that choice).

I’m guessing you want a single module as the public API and the module would be too large to have the implementations of all functions? If that’s the case look into using defdelegate Kernel — Elixir v1.16.0.

@ericmj I don’t seem to understand the example provided in the docs,

defmodule MyList do
  defdelegate reverse(list), to: :lists
  defdelegate other_reverse(list), to: :lists, as: :reverse
end

MyList.reverse([1, 2, 3])
#=> [3, 2, 1]

MyList.other_reverse([1, 2, 3])
#=> [3, 2, 1]

But it’s still being called with MyList (the module where they’re defined?) and they “delegate” to :lists, which is?

In my case what I was aiming at was, for instance given:

defmodule AetherWars.Duels.Stack do
def place_in_stack(state, {"gift", player, %{"from" => from, "source" => uuid, "type" => type, "payment" => %{"payment" => payment}} = gift}) do
        with {:ok, g_scroll}  <- get_in_play(state, player, type, uuid, from),
             {:ok, g_gift}    <- legal_gift?(state, player, g_scroll, gift, from),
             {:ok, int_state} <- pay_cost(state, player, g_gift["cost"], payment),
             {:ok, new_state} <- place_gift_in_stack(int_state, player, g_gift, g_scroll, gift, from)
            do
              IO.puts("ready to pass priority after gift stack")
              pass_priority(new_state, player, switch_player(player))
        else
          {:error, msg, _} -> {:error, msg, state}
        end
      end
end

That I would be able to just call this function as place_in_stack from inside AetherWars.Duels.Processor, hence my usage of use.

Itself it calls functions from .Utils and .Legal, but ultimately I see them all as functions from Duels.Processor. Mostly because I’ve decided to always pass the game state, “state”(a json representation of the whole game) is always the first argument to any interaction so mentally I was seeing them as part of the same module, but due to the sheer size I wanted to break them out into different files for easier navigation (and editing).

Now I’m questioning if they should actually be different decoupled modules - but again they only make sense when dealing with a game state that is exactly this structure?