Global constants and pattern matching

Just to make sure: those prefixes are not changing during runtime, correct?

That’s correct, they are essentially permanent. I just hate having to redefine them everywhere: it’s a mess, and a typo would be easy to make and very bad.

Then I would go for the __using__ approach but would not hard-code the values there; I’d make them part of the application’s config and just use Application.compile_env in the code that’s injected via the macro. That would help with the single source of truth problem.

This is contextual enough that I would not expect you to understand, but in this particular case the values are “implementation details” in such a way that using config seems like the wrong choice. It would be like defining magic numbers for a file format using config options - not quite right. These values are not going to change.

Anyway, I don’t love the __using__ approach because I feel like it’s less discoverable. At some point someone is going to read my code and wonder where @prefix came from, and it’s not going to be defined. I don’t like that.

If I use individual macros at least they will have a clear definition somewhere discoverable.

In that case and with that context I’d agree with you. Though it has to be said I find both suboptimal in different ways but I don’t see a [much] better way myself.

I don’t hate the __using__ method for those cases that are truly global and/or want to be used in function heads.

It is a little less discoverable but it doesn’t take me too long to see the use MyModuleAttrubuteConstants at the top of the module and remember what I’ve done.

Use global public macros as constants then.

defmodule Prefixes do
  defmacro prefix(prefix \\ "foo", rest) do
    case __CALLER__.context do
      :match -> 
        quote generated: true, do: unquote(prefix) <> unquote(rest)
    end
  end
end

defmodule Usage do
  import Prefixes, only: [prefix: 1]

  def something(prefix(key)), do: key
end

Resulting in:

iex(2)> Usage.something "ggg"
** (FunctionClauseError) no function clause matching in Usage.something/1    
    
    The following arguments were given to Usage.something/1:
    
        # 1
        "ggg"
    
    iex:6: Usage.something/1
    iex:5: (file)
iex(5)> Usage.something "fooggg"
"ggg"

This is clever, thanks for the reply.

What I had in mind (my second idea) was something slightly simpler:

defmodule Prefixes do
  defmacro prefix, do: "foo"
end

defmodule Usage do
  import Prefixes
  def something(prefix() <> rest), do: rest
end

I like this a bit more because I think the syntax is less surprising. It looks almost exactly like a module attribute except it can be used anywhere, plus it’s discoverable.

One thing I was wondering is: does anyone know whether this would have any performance impact (at least at compile time)? I would think it would be insignificant.

Well, Elixir macros are being expanded during compile-time and the AST they return is being directly injected into a resulting beam code. That said, the runtime would have zero impact compared to something("foo" <> rest) because _this is exactly the code the VM machine would see.

Duting the compilation time, yeah, it’ll gorge a couple of processor ticks, but you’d never notice this.