Thread by @BrooklinJMyers

Chapter 2 of Metaprogramming Elixir by @chris_mccord

You can get a copy here:
pragprog.com/titles/cmelixi…

Summarizing so you can get the key takeaways! 🧵

#elixirnewbie #myelixirstatus

0/11

Macros can be used for powerful code generation. They can save time, reduce boilerplate, and produce elegant APIs. To realize the power of macros, remember that most of the Elixir Standard library is implemented as macros.

1/11

You have the freedom to extend the language and implement your own desired features. Macros allow you to create your own keywords and allow Elixir to be flexible for future requirements.

2/11

For example, you could create your own macro to run comprehensions in parallel! That might look like

para(for i <- 1..10 do: i * 10)

3/11

With access to the AST, macros gain insight into the meaning of each expression passed into it, not just the values, but the true meaning of the expression

4/11

For example: a typical testing framework given "assert 10 < 1" would simply print "expected true, got false". Which isn't useful. But with macros, you gain the ability to provide further insight. "expected 10 to be less than 1".

5/11

You accomplish this through a smart assert macro that has the ability to understand the left value, right value, and operator passed into it. You then leverage pattern matching to print a more comprehensive message "expected {lhs} to be less than #{rhs}"

6/11

bind_quoted unquotes arguments and prevents accidental reevaluations.

defmacro assert({operator, _, [lhs, rhs]}) do
quote bind_quoted: [lhs: lhs, rhs: rhs, operator: operator] do
...

bind_quoted disables unquote unless you pass the unquote: true option.

7/11

The core purpose of macros is to inject code into a module to extend their behavior. The `use` macro provides a common API for module extension. `use` is simply a macro that injects code from the __using__ macro definition from another module.

8/11

Module attributes allow data to be stored at compile-time. in a macro definition, you can use the accumulate: true option to keep a list of registrations during compile time.

import unquote(__MODULE__)
Module.register_attribute(__MODULE__, :example, accumulate: true)

9/11

Elixir provides a before_compile hook when you want to delay macro expansion until your module attributes have been registered. a __before__compile/1 macro must then be defined.

10/11

Hope you enjoyed this summary! As usual, I'm not affiliated. I just do these summaries for fun and to learn.

I recommend you pick up your own copy of Metaprogramming Elixir! pragprog.com/titles/cmelixi…

11/11