garrison
Global constants and pattern matching
A library I’m working on has a lot of functionality related to string prefixes (technically binaries, but they’re mostly strings). I have to add prefixes to keys a lot, and I have to pattern match them back off a lot.
Like:
defp prefix(key), do: "foo/" <> key
defp is_foo("foo/" <> key), do: true
defp is_foo(_key), do: false
And so on. But a lot of this functionality is embedded in application code, in anonymous functions, in Enum.maps, variable assignments, and so on. It’s everywhere.
I want to standardize these prefixes across the codebase going forward. They are already standardized, of course, but I have module attributes scattered across a couple dozen modules when I want them to be in one place.
There is, essentially, a lot of code like this, with the attributes duplicated across many modules:
@prefix "foo"
defp something(@prefix <> rest), do: rest
The docs recommend using public functions as constants instead of attributes, but this doesn’t work because I also need to use them for pattern matching everywhere.
I can think of two approaches off the top of my head:
First, use a module with a __using__ macro to inject the same set of attributes into every module. This would be acceptable for my use case, but it seems kinda cursed.
Second, replace the attributes with macros that inject the constants into the expressions. Essentially, the function-as-constant approach but with a macro instead. This sounds more sane to me, and is what I’ll probably do, but I figured I should seek some guidance in case I’ve overlooked something. This approach is conspicuously absent from the docs I linked.
Most Liked
cmo
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.
mudasobwa
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"
mudasobwa
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.
dimitarvp
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.
garrison
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.
Popular in Questions
Other popular topics
Latest on Elixir Forum
Sponsor Spotlight
Courses that'll move you from confusion to "Aha, now I get it!"
Categories:
Sub Categories:
Forums
Our Sponsors
Build Elixir applications with speed and confidence.
Supporting innovation across the BEAM ecosystem.
We build reliable cloud platforms for business-critical systems.
Catch errors, track performance, monitor hosts and more.
Practical resources that improve the lives of professional developers.
Producing high quality Elixir screencasts since 2017.
The deployment platform built for Elixir: PaaS ease, VPS control.
Courses that'll move you from confusion to "Aha, now I get it!"