Batch delegate functions to a module?

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

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.

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.

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.