Getting Line Error on stack trace when "using" modules

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…).

Generated code will use the stacktrace location of the caller. This is a good default for most macros since generated code should be kept to a minimum, the fact that you need the location of the generated code in the stacktrace is an indication that you are overusing it. Using use that expands to function definitions with the full implementation for composition is an anti-pattern.

If you do need the line information from the macros add location: :keep to the quoted code: quote location: :keep do ... end.

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.20.2.

@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?

When you use this way you actually define the functions inside the calling module. Why should they be defined there instead of the module where the code is located? What is wrong with calling functions at the module where they are located in the source code? If it’s annoying to prefix the module name before the function call maybe you should alias or import the module where the function is defined instead of moving the definition itself with use?

Besides my mental model when projecting this (and having to change function calls in so many places), nothing is wrong with calling functions where they’re located in the source code - I tend to do that usually ah. alias still implies calling the module name, and import I think I tried but then I would need to “import” things in multiple places - like in the sample, I would need to import “utils” & “legal” & “payment” and then in “payment” and “legal” probably import “utils” again, and so on, otherwise they would break.

Perhaps it’s just bad architecture but given that I’m creating it as I go and don’t have the whole engine yet designed/thought about…

Thanks for your patience and suggestions. I will give this some thought (to break it up in the future) - and for now just add the trace