Iteratively calling "use" on a list of modules?

for mod <- @mods, do: quote do: use unquote(mod)

is equivalent to

for mod <- @mods do 
  quote do 
    use unquote(mod)
  end
end

Note that the quote do there just causes the AST A.K.A “quoted code” to be returned. Nothing is actually evaluating it.

Try this (haven’t verified that it works). In a different module, make a macro called use_all.

defmodule SomeModule do
  # explicitly expects a module attribute to be given to it
  defmacro use_all({:@, _, [{name, _, _}]}) do
      for module <- Module.get_attribute(__CALLER__.module, name, []) do
        quote do
           use unquote(module)
        end
      end
    end
  end
end

Then in your module you can use

SomeModule.use_all(@attr)

There is a simpler way that is perhaps a bit less hygienic as its typically recommended to avoid Code.eval_quoted, but you could do this:

for mod <- @mods do
  quote do
    use unquote(mod)
  end
  |> Code.eval_quoted([], __ENV__)
end

Thanks! I knew I was on the right track and I was staring at the source code for use in the Kernel but hadn’t remembered that the AST I was generating wasn’t being evaluated…

I haven’t tested the more complex solution but I’ll give it a spin tomorrow and report back for future readers.

Honestly I think it may just be the right way. I’m not sure why I was thinking one should avoid Code.eval_quoted, but I think that usage of it is perfectly reasonable.

I can’t get this one to work. Isn’t this going to result in each use being scoped to for’s block? I have a poor mental model of using quote directly in a module body, though I was trying other stuff earlier (somewhat akin to your first answer, though not quite) and no luck there either I actually can’t get the first example working either, says that @mods is unused.

Oh that would be funny if I found a bug in the compiler or something. I’m already using that @mods equivalent in another function so it wouldn’t error as unused. See if that solves it for you?

You’re right

Here is a working example:

defmodule Foo do
  defmacro __using__(_) do
    quote do
      import Integer
    end
  end
end

defmodule MultiUse do
  # must be a literal list
  defmacro __using__(mods) do
    using_code =
      for module <- Macro.expand_literals(mods, __CALLER__) do
        quote do
          use unquote(module)
        end
      end

    setter = quote do
      @using_modules unquote(mods)
    end

    [setter | using_code]
  end
end

defmodule Bar do
  use MultiUse, [Foo]
  @using_modules |> IO.inspect()
  digits(12)
end

This demonstrates that you can use the list again later w/ @using_modules, and things like import affect the top level scope.

Yes, sorry, I shouldn’t have focused on the warning. It doesn’t accomplish the use for me is the main thing. I could be doing it wrong though, it’s getting a bit late for me.

Oh, this is clever! This code (without the @using_modules part) is very close to what I had working with the problem being that it failed passing it a module attribute. Instead of expand_literals, though, I used expand_once. Is there a big difference here? I never quite understood the docs of expand_literals though it actually sounds like might be equivalent in this case? Both have to do with expanding aliases properly?

I think they’re equivalent here, yeah.