{"id":10996,"date":"2024-07-21T10:37:24","date_gmt":"2024-07-21T10:37:24","guid":{"rendered":"https:\/\/putridparrot.com\/blog\/?p=10996"},"modified":"2024-07-21T10:37:24","modified_gmt":"2024-07-21T10:37:24","slug":"more-modules-in-elixer","status":"publish","type":"post","link":"https:\/\/putridparrot.com\/blog\/more-modules-in-elixer\/","title":{"rendered":"More modules in Elixer"},"content":{"rendered":"

In the post A little more Elixir, we\u2019re talking modules and functions<\/a> we looked at a basic use of modules to allows us to declare functions (and macros, although we’ve not really touched these yet). <\/p>\n

Modules can be nested, for example<\/p>\n

\r\ndefmodule Math do\r\n  defmodule Fractions do\r\n  # Nested module and functions \r\n  end\r\n\r\n  # Top level module an functions\r\nend\r\n<\/pre>\n
These don’t actually have a relationship with one another, instead Elixir essentially has them as separate modules, like this<\/p>\n
\r\ndefmodule Math do\r\n  # functions\r\nend\r\n\r\ndefmodule Math.Fractions do\r\n  # functions\r\nend\r\n<\/pre>\n
Importing modules<\/strong><\/p>\n
The import<\/em> keyword (as the name suggests) imports a module’s functions and\/or macros into the scope of the module or function they’re imported into. The scope is limited to that defined by the start and end of the module or function. Importing allows us to call functions from the module without having to use it’s module name. For example, we have a Math<\/em> module with functions add<\/em> and sub<\/em> but we import it into our function like this<\/p>\n
\r\ndef f do \r\n  import Math\r\n  add(1, 7)\r\nend\r\n<\/pre>\n
Notice how the highlighted line does not need to prefix the module name to the function.<\/p>\n
We can limit what’s imported using additional syntax where where we have only:<\/em> or except:<\/em> to reduce the scope of imports to the minimal, for example we do not need sub<\/em> in our import so we could write<\/p>\n
\r\ndef f do \r\n  import Math, only [add: 2]\r\n  add(1, 7)\r\nend\r\n<\/pre>\n
In the above we import only<\/em> the add<\/em> function with arity of 2 (i.e. the 2 parameter function named add<\/em>).<\/p>\n
Aliasing modules<\/strong><\/p>\n
As the name suggests, alias<\/em> allows us to create an alias to a module name, for example let’s say we have Math.Fractions<\/em> whilst not a big deal to type if we’re typing it for every function it create a lot of “clutter” in our code, so instead we can alias the name like this<\/p>\n
\r\ndefmodule TestMod do\r\n  alias Math.Fraction, as: F\r\n  def f do\r\n    F.some_function()\r\n  end \r\nend\r\n<\/pre>\n
Require a module<\/strong><\/p>\n
The require<\/em> keyword ensure the macro definitions of a module are compiled into the scope using the require<\/em>. Or to put this another way require<\/em> ensures that a required module is loaded before the module that’s calling into it. This will ensure any macros within it are available to the calling module and they’re scoped to that calling module. <\/p>\n
Note: require is not like an alias, so you still need to prefix any macro\/function calls with the module name (unless you also alias it ofcourse)<\/em><\/p>\n
An example might be something like this<\/p>\n
\r\ndefmodule A do\r\n  defmacro hello(arg) do\r\n    quote do\r\n      IO.puts "Hello #{unquote(arg)}"\r\n    end\r\n  end\r\nend\r\n\r\ndefmodule B do\r\n  def hello_world() do\r\n    A.hello "World"\r\n  end\r\nend\r\n<\/pre>\n
In the above, if you compile this into iex using c(“require_sample.rx”)<\/em> you’ll get warnings such as warning: you must require A before invoking the macro A.hello\/1<\/em> if you try to execute the command B.hello_world(“Scooby”)<\/em> you’ll get an error like this ** (UndefinedFunctionError) function A.hello\/1 is undefined or private. However, there is a macro with the same name and arity. Be sure to require A if you intend to invoke this macro<\/em>.<\/p>\n
So as you can see, we need to use require<\/em>, simply add the require A<\/em> as below<\/p>\n
\r\ndefmodule A do\r\n  defmacro hello(arg) do\r\n    quote do\r\n      IO.puts "Hello #{unquote(arg)}"\r\n    end\r\n  end\r\nend\r\n\r\ndefmodule B do\r\n  require A\r\n  def hello_world() do\r\n    A.hello "World"\r\n  end\r\nend\r\n<\/pre>\n
The use macro<\/strong><\/p>\n
The use<\/em> macros allows us to “inject” any code into the current module. It’s used as an extension point.<\/p>\n
I’ll dedicate a post of it’s own to the use<\/em> keyword as it’s interesting what you can do with it.<\/p>\n
Module Attributes<\/strong><\/p>\n
Attributes in Elixir are prefixed with the @ symbol. These add metadata to our module. An attribute is declared as a @name value<\/em> pair. Whilst the name can be pretty much anything (within the allowable syntax), for example I might have a @my_ver 1<\/em>, there are some reserved names<\/p>\n
    \n
  • @moduledoc is use for module documentation<\/li>\n
  • @doc is use for function or macro documentation<\/li>\n
  • @spec is use to supply a typespec for the function which follows<\/li>\n
  • @behaviour is used for OTP or under-defined behaviour (and yes it’s the UK spelling)<\/li>\n<\/ul>\n
    Here’s an example of creating our own attribute and we’re able to use it within our functions<\/p>\n
    \r\ndefmodule Attributes do\r\n  @some_name PutridParrot\r\n\r\n  def attrib() do\r\n    @some_name\r\n  end\r\nend\r\n<\/pre>\n
    This will return the @some_name value.<\/p>\n
    You can set the attribute multiple times within the module scope. Elixir evaluates from top to bottom so functions after a change to the @some_name (above) will get the new value.<\/p>\n","protected":false},"excerpt":{"rendered":"
    In the post A little more Elixir, we\u2019re talking modules and functions we looked at a basic use of modules to allows us to declare functions (and macros, although we’ve not really touched these yet). Modules can be nested, for example defmodule Math do defmodule Fractions do # Nested module and functions end # Top […]<\/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-10996","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\/10996","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=10996"}],"version-history":[{"count":5,"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/posts\/10996\/revisions"}],"predecessor-version":[{"id":11013,"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/posts\/10996\/revisions\/11013"}],"wp:attachment":[{"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/media?parent=10996"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/categories?post=10996"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/tags?post=10996"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}