Gain insights into metaprogramming in Elixir. Delve into macros and discover how to elevate your coding skills, creating powerful libraries with concise, efficient code.

_Metaprogramming Elixir by The Pragmatic Programmer_468 x 60 copy.png

elixir.tar.gz

elixir

elixir-testing

elixir-copy

Get introduced to the concept of metaprogramming. Learn how to level up your programming skills by discovering the full potential of the macro system in Elixir. Understand the ins and outs of metaprogramming at a fundamental level and write incredible libraries by doing more with less code.

Metaprogramming in Elixir

We’ve unlocked many of Elixir’s metaprogramming secrets. We went from the basics to writing our own language features. Along the way, we gained insight into Elixir’s internals and probably found a new appreciation for the language’s syntax and idioms. Without curbing the excitement, we’re going to review some tips and tricks for getting the most out of Elixir’s macro system and avoiding common pitfalls. Staying on the happy path of metaprogramming will let us write extensible code, which is easy to write and maintain.



# The trial terminal
Use the following terminal to try and execute the commands given in the lesson:



# The correct use of macros
Elixir is a language built on top of macros, so it’s easy to think that every library needs macros. This isn’t the case! Macros should be reserved for specialized cases where the solution can’t be implemented easily as normal function definitions. Whenever writing code and reaching for `defmacro`, stop and ask whether the solution requires code generation. Sometimes, code generation is required, but other times writing functions works better. i So, don’t get too carried away with macros.

In some cases, the choice for macros is easy. Macros are the obvious choice for things like control flow, where access to the AST expression is required. For example, let’s imagine trying to implement `if` as a function instead of a macro, similar to the lesson [Custom Language Constructs of Chapter 3](https://www.educative.io/courses/metaprogramming-elixir/custom-language-constructs). 
``` ELIXIR
iex> defmodule ControlFlow do
...>   def if(expr, do: block, else: else_block) do
...>     case expr do
...>       result when result in [nil,false] -> else_block
...>       result -> block
...>     end
...>   end
...> end
# Output: 
# {:module, ControlFlow,
# <<70, 79, 82, 49, 0, 0, 5, 120, 66, 69, # 65, 77, 69, 120, 68, ...

iex> ControlFlow.if true do
...>   IO.puts "It's true!"
...> else
...>   IO.puts "It's false!"
...> end
# Output:
# It's true! 
# It's false!

```
Both of the `IO.puts` expressions were evaluated because they were passed to the `if` function at runtime. Macros are an obvious requirement here because we must convert the expression at compile time into a case expression to avoid runtime evaluation of both clauses. Other times, the choice is not as obvious.


In creating [Phoenix](https://www.phoenixframework.org/), an Elixir web framework, macros were used for its router layer. The case for macros in the Phoenix router is twofold: 
- First, it allows for an expressive and easy-to-use routing DSL. 
- Second, it generates many clauses internally that a user would’ve had to write by hand. 

Let’s look at a high-level overview of the kind of code the router generates. Then, we can talk about the macro tradeoffs. Here’s a minimal Phoenix router that routes HTTP requests to controller modules:
``` elixir
defmodule MyRouter do 
  use Phoenix.Router

  pipeline :browser do
    plug :accepts, ~w(HTML) 
    plug :fetch_session
  end

  scope "/" do
    pipe_through :browser

    get "/pages", PageController, :index
    get "/pages/:page", PageController, :show 
    resources "/users", UserController do
      resources "/comments", CommentController 
    end
  end 
end
```
After `MyRouter` is compiled, [Phoenix](https://www.phoenixframework.org/) generates function heads on the module that look like this:
``` elixir
defmodule MyRouter do
...
  def match(conn, "GET", ["pages"])
  def match(conn, "GET", ["pages" , "page"])
  def match(conn, "GET", ["users", "new"])
  def match(conn, "POST", ["users"])
  def match(conn, "PUT", ["users", id])
  def match(conn, "PATCH", ["users", id])
  def match(conn, "DELETE",["users", id])
  def match(conn, "GET", ["users", "user_id", "comments"])
  def match(conn, "GET", ["users", "user_id", "comments", id, "edit"])
  def match(conn, "GET", ["users", "user_id", "comments", id])
  def match(conn, "GET", ["users", "user_id", "comments", new])
  def match(conn, "POST", ["users", "user_id", "comments"])
  def match(conn, "PUT", ["users", "user_id", "comments", id])
  def match(conn, "PATCH", ["users", "user_id", "comments", id])
  def match(conn, "DELETE",["users", "user_id", "comments", id])
end
```
The Phoenix router uses macros such as `get`, `post`, and `resources` to convert an HTTP DSL into a series of `match/3` definitions. We have used macros for Phoenix’s router because after weighing the trade-offs, we notice the routing DSL not only provides a high-level API for routing HTTP requests but also removes dozens of lines of boilerplate that would need to be written by hand. This comes at the cost of code-generation complexity, but the payoffs make macros a clear win. Macros require careful consideration on the balance of convenience over complexity.

When using macros in Phoenix, we should strive for the simplest solution possible. The caller trusts that the generated code is simple and fast. This should be our implicit contract with the caller for any code wegenerate.


The most important metaprogramming strategy is to keep it simple. Striking a balance between library power, ease of use, and internal complexity is a careful game we must play. In the next lesson, we’ll see how to keep it simple and which hazards to avoid.

Learn the tips and tricks for the correct use of macros.

Introduction

The Language of Macros

Extending Elixir with Metaprogramming

Advanced Compile-Time Code Generation

Code Generation from Git API

How to Test Macros

Create an HTML Domain-Specific Language

With Great Power Comes Great Responsibility (and Fun!)

When and Where to Use Macros