31

I have this module in elixir with an attribute:

defmodule MyAwesomeModule do @awesome_number 7 # other stuff... end

I'm unable to access @awesome_number outside the module. I've tried using the Module.get_attribute/2 method, but it throws this error:

iex(79)> Module.get_attribute(MyAwesomeModule, :awesome_number) ** (ArgumentError) could not call get_attribute on module MyAwesomeModule because it was already compiled (elixir) lib/module.ex:1101: Module.assert_not_compiled!/2 (elixir) lib/module.ex:1016: Module.get_attribute/3

So right now, I'm wrapping the module attribute in a method to access it, but it doesn't really make sense to me. I could simply use the method and stop using the attribute all together:

defmodule MyAwesomeModule do @awesome_number 7 def awesome_number, do: @awesome_number # other stuff... end

So my question is, is there a better / proper way of doing this?

Improve this question

2 Answers 2

Reset to default
34

AFAIK there is no way to access the module attributes outside of the given module. Defining a function to expose the module attribute is the way to go, just what you are already doing.

There still could be a good reason to keep the module attribute, instead of just using the function without the module attribute. It depends on the context. Keep in mind that the value stored in the module attributes is calculated at compilation time. That being said you could have different reasons to use or not to use the module attribute. Let's look at the following examples:

If the awesome_number have to be random generated every time when it's accessed, you have to go just with a function.

If the awesome_number needs to be computed (long time) and it doesn't have to change its value, then going with the module attribute + function to expose it, is the way to go.

Edit:

There is more to module attributes from what I've said earlier. They perform better than just functions. Here is an example and a quote from the elixir docs:

defmodule MyServer do @my_data 14 def first_data, do: @my_data @my_data 13 def second_data, do: @my_data end MyServer.first_data #=> 14 MyServer.second_data #=> 13

Notice that reading an attribute inside a function takes a snapshot of its current value. In other words, the value is read at compilation time and not at runtime. As we are going to see, this makes attributes useful to be used as storage during module compilation.

Using them with Module.register_attribute/3 (https://hexdocs.pm/elixir/Module.html#register_attribute/3) and especially with the accumulate: true option, makes them useful in more ways.

What I want to say is that they can be more useful than just being used as a constant.

Improve this answer
Sign up to request clarification or add additional context in comments.

3 Comments

Elixir's Plug library is a good example of using the module attributes with accumulate: true. Here is a link if you want to dig more in the source github.com/elixir-lang/plug/blob/…
Can u please provide the reference for the following part of the answer? I would like to read more about this :) Notice that reading an attribute inside a function takes a snapshot of its current value.
Never mind its part of the doc elixir-lang.org/getting-started/…
22

There is a way of "cheating" by using use and macros. Look at this example.

For instance suppose you define a module as:

defmodule AwesomeLibrary do defmacro __using__(_) do quote do def print(s), do: IO.puts(s) end end end

Then, in some module you can use the use keyword in this way.

defmodule TestLibrary do use AwesomeLibrary end

The effect is that everything defined in the __using__ block is copied in the new module at compile time. So, in that case, you can use TestLibrary.print even if print is defined in another module.

This can be used to 'copy constants' too:

defmodule AwesomeLibrary do defmacro __using__(_) do quote do @awesome_number 7 def print(s), do: IO.puts(s) end end end

An example of this that you can look at is the Timex library. It uses a dedicated module for constants that is imported whenever it is needed.

This seems to me the nicer way to share constants definitions around a big codebase.

Improve this answer

2 Comments

That's a great link in TimeX. This is also how I am using them. I created a concept app to look at the different ways of sharing "constants" across projects: github.com/bill-mybiz/elixir-constants-concept . I've also created an SO "Documentation" on constants ("in review" right now), because this is one of the few areas elixir's documentation isn't so strong on. (Just about everything else is documented brilliantly). Another benefit of this method is that you can use them inside of guard statements (since it's compile-time).
If you just want to use print/1 in other modules, you can simply import the AwesomeLibrary, no need for the use/2 and __using__/1 macros.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.