To clarify things a bit. In module Whatever you are only defining one function do_thing/1 which has two clauses. While it looks 2 separate functions they are actually parts of the same function. In the modules Foo and Bar you are defining 2 different functions do_thing/1 so now you have 3 functions do_thing/1 in separate modules. What uniquely defines a function is the module its in, its name, and its arity (number of arguments). Importing does not change that, it just gives you a way of not having to prefix calling a function in another module with the module name. You still have 3 different do_thing/1 in 3 modules.

Hi, @rschooley! That’s a pretty abstract question/sample hehe

But, if your do_thing is a call that make a thing so different with each kind of record, I would guess that it structure changes a lot depending on its source. If is that the case, I think it make sense that each type of record is a struct and that exist a ThingDoer protocol, so you could easily extend this thing to be done to other record types in the future. It would be something like that:

defmodule FooRecord do
  defstruct [:content, source: "foo"]
end

defmodule BarRecord do
  defstruct [:content, source: "bar"]
end

defprotocol ThingDoer do
  def do_thing(record)
end

defimpl ThingDoer, for: FooRecord do
  def do_thing(record), do: IO.puts("calling foo")
end

defimpl ThingDoer, for: BarRecord do
  def do_thing(record), do: IO.puts("calling bar")
end

defmodule ThingDoerBoss do
  def handle_info(:get_thing_doers_to_work, state) do
    [
      %FooRecord{content: "lol"},
      %BarRecord{content: "xpto"},
    ]
    |> Enum.each(&ThingDoer.do_thing/1)
  end
end

With that solution you can easily extend the do_thing to other source structures and also have the record structures documented.

PS.: In that case, your SomeContext.some_query must return the records as structs.

PS2.: I would not recommend you to use this import overriding thing even if it worked, it seems that would be a hell of situation to navigate through modules trying to discover in which of them are the matching function hehe

I think you can simply include the module when calling the function with Foo.do_thing(), and that importing or aliasing a module is “just” a way to avoid having to use the module name for every call.

Edit: see here and here for fuller and more accurate information.