{"id":11014,"date":"2024-07-21T14:32:44","date_gmt":"2024-07-21T14:32:44","guid":{"rendered":"https:\/\/putridparrot.com\/blog\/?p=11014"},"modified":"2024-07-21T14:32:44","modified_gmt":"2024-07-21T14:32:44","slug":"elixir-use-and-using","status":"publish","type":"post","link":"https:\/\/putridparrot.com\/blog\/elixir-use-and-using\/","title":{"rendered":"Elixir, use and using"},"content":{"rendered":"

I didn’t include much information in my post More modules in Elixer<\/a> around the use<\/em> macro and that’s because it really requires a post on it’s own. So here we go…<\/p>\n

If you’ve uses Phoenix (partially covered in Elixir and Phoenix<\/a>) you’ll have probably noticed that when we created the controller we gained access to functions such as json<\/em> and when we setup the router we had a long list of except:<\/em> atoms. This is because using use<\/em> bought functions into the modules from Phoenix automatically, i.e. new, edit, create etc. functions.<\/p>\n

The use<\/em> macro is quite powerful, it essentially calls the __using__ macro within another module. The __using__ macro allows us to inject code from the other module. <\/p>\n

Let’s see this in action…<\/p>\n

We’ll start by creating a module which will include functionality that can be injected into another module<\/p>\n

\r\ndefmodule MyUse do\r\n  defmacro __using__(_opts) do\r\n    quote do\r\n      def my_injected_fn() do\r\n        "Hello World"\r\n      end\r\n    end\r\n  end\r\nend\r\n<\/pre>\n
In the above example, we create the macro with the my_injected_fn<\/em>. The neat bit is the __using__<\/em> which injects this code into a module which uses the MyUse<\/em> module, for example<\/p>\n
\r\ndefmodule MyModule do\r\n  use MyUse\r\n\r\n  def test_use() do\r\n    my_injected_fn()\r\n  end\r\nend\r\n<\/pre>\n
This will inject all macros, but in the Phoenix example we want to inject only certain pieces from a module. <\/p>\n
Before we move on let’s quickly address a couple of things in the code above. The quote<\/em> macro tranforms the block of code into an AST (Abstract Syntax Tree), we can see an example of this by type the following into iex quote do: MyModule.testuse()<\/em> and it will display something like {{:., [], [{:__aliases__, [alias: false], [:MyModule]}, :testuse]}, [], []}<\/em>. It’s probably quite obvious that defmacro<\/em> defines a macro and the __using__<\/em> calback macro is what allows us to extend other modules (as already mentioned).<\/p>\n
Let’s change the MyUse<\/em> module to allow us to inject specific functionality.<\/p>\n
\r\ndefmodule MyUse do\r\n  defmacro __using__(which) when is_atom(which) do\r\n    apply(__MODULE__, which, [])\r\n  end\r\n\r\n  def injector do\r\n    quote do\r\n      def my_injected_fn() do\r\n        "Hello World"\r\n      end\r\n    end\r\n  end\r\nend\r\n<\/pre>\n
We’re now using the macro __using__ to select which bits of functionality we want to inject into another module. Admittedly in this example we just have a single piece of code to be injected, but bare with me.<\/p>\n
So now to use this in our other modules we write the following<\/p>\n
\r\ndefmodule MyModule do\r\n  use MyUse, :injector\r\n\r\n  def test_use() do\r\n    my_injected_fn()\r\n  end\r\nend\r\n<\/pre>\n
This will inject the injector<\/em> defined code.<\/p>\n
Let’s be honest this is not that useful with one function, so let’s extend the MyUse<\/em> with a couple of functions (in my case, just to demonstrate things I’ve given them the same name  but in most modules you’ll probably not be doing this<\/p>\n
\r\ndefmodule MyUse do\r\n  defmacro __using__(which) when is_atom(which) do\r\n    apply(__MODULE__, which, [])\r\n  end\r\n\r\n  def injector1 do\r\n    quote do\r\n      def my_injected_fn() do\r\n        "Hello World 1"\r\n      end\r\n    end\r\n  end\r\n\r\n  def injector2 do\r\n    quote do\r\n      def my_injected_fn() do\r\n        "Hello World 2"\r\n      end\r\n    end\r\n  end\r\nend\r\n<\/pre>\n
What we’re going to do, is in the calling module, we can select injector1 OR injector2 an without changing the calling function name (as it’s unchanged in the MyUse<\/em> module)<\/p>\n
\r\ndefmodule MyModule do\r\n  use MyUse, :injector1\r\n\r\n  def test_use() do\r\n    my_injected_fn()\r\n  end\r\nend\r\n<\/pre>\n
This will display “Hello World1” when evaluated. Switching the :injector2 will display “Hello World 2.<\/p>\n
As mentioned it’s unlikely you’ve normally do this, it’s much more likely you might include different functions, maybe along these lines<\/p>\n
\r\ndefmodule MyUse do\r\n  defmacro __using__(which) when is_atom(which) do\r\n    apply(__MODULE__, which, [])\r\n  end\r\n\r\n  def injector1 do\r\n    quote do\r\n      def hello1() do\r\n        "Hello World 1"\r\n      end\r\n    end\r\n  end\r\n\r\n  def injector2 do\r\n    quote do\r\n      def hello2() do\r\n        "Hello World 2"\r\n      end\r\n    end\r\n  end\r\nend\r\n<\/pre>\n
Now we can inject these via use<\/em>, like this<\/p>\n
\r\ndefmodule MyModule do\r\n  use MyUse, :injector1\r\n  use MyUse, :injector2\r\n\r\n  def test_use() do\r\n    IO.puts hello1()\r\n    IO.puts hello2()\r\n  end\r\nend\r\n<\/pre>\n
Note: I’m still quite new to Elixir, the usage of two use clauses seems a little odd, there may be a better way to define such things.<\/em><\/p>\n
I mentioned you could use import<\/em> in much the same way, except use<\/em> allows us to inject aliases, imports other use modules etc. <\/p>\n
References<\/strong> <\/p>\n
The \u2018use\u2019 Macro in Elixir.<\/a>
\nUnderstanding Elixir\u2019s Macros by Phoenix example<\/a>
\nHow to Use Macros in Elixir<\/a>
\nPhoenix repo on GitHub<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
I didn’t include much information in my post More modules in Elixer around the use macro and that’s because it really requires a post on it’s own. So here we go… If you’ve uses Phoenix (partially covered in Elixir and Phoenix) you’ll have probably noticed that when we created the controller we gained access to […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_jetpack_memberships_contains_paid_content":false,"footnotes":""},"categories":[730],"tags":[],"class_list":["post-11014","post","type-post","status-publish","format-standard","hentry","category-elixir"],"jetpack_sharing_enabled":true,"jetpack_featured_media_url":"","_links":{"self":[{"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/posts\/11014","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/comments?post=11014"}],"version-history":[{"count":3,"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/posts\/11014\/revisions"}],"predecessor-version":[{"id":11017,"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/posts\/11014\/revisions\/11017"}],"wp:attachment":[{"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/media?parent=11014"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/categories?post=11014"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/tags?post=11014"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}