Batch delegate functions to a module?

There’s a better way to do this if module_path is a list of strings:

module_path
|> Enum.map(&String.to_atom/1)
|> Module.concat()

If it’s a list of atoms (like it seems to be from your post) then just remove the Enum.map part and use Module.concat directly.

necrobump time. here’s my ready made script that supports different arities and a custom list of modules to combine into one.

defmodule MyApp.FullHouse do
  use MyApp.FullHouse.Populate,
    context_modules: [
      MyApp.ModuleA,
      MyApp.ModuleB,
      MyApp.ModuleC,
      MyApp.ModuleD
    ]
end

defmodule MyApp.FullHouse.Populate do
  require Logger

  defmacro __using__(opts) do
    modules =
      for {_, _, module_path} <- opts[:context_modules] do
        ("Elixir." <> Enum.join(module_path, "."))
        |> String.to_atom()
      end

    for module <- modules, {fun, arity} <- apply(module, :__info__, [:functions]) do
      quote do
        defdelegate unquote(fun)(unquote_splicing(Macro.generate_arguments(arity, module))),
          to: unquote(module)
      end
    end
    |> tap(fn x -> Logger.info("Service Layer has #{length(x)} functions.") end)
  end
end

Dunno if this is efficient or not, I’m just using this for prototyping to think my way to a better process. Pretty bad code smell if this ends up in production.

This is a very valid way but for what it’s worth I’d either add all delegates by hand or make a short sed or awk script do it for me.

Using metaprogramming for such a simple task hurts readability and the ease of future reverse-engineering effort required to maintain the code.

Just adding nuance to your already valid advice.

You can use some simple meta programming like this:

defmodule Delegate do
  @delegate_functions ~w(a b c d e f)a
  
  for fun <- @delegate_functions do
    defdelegate unquote(fun)(), to: OtherModule
  end
end