Implement new Concept Exercise: `macros`

[angelikatyborska]

Learning objectives

• defmacro
• the Macro module
• what's an AST
• when not to use macros

Out of scope

I am not sure if explaining require/use in the same exercise would be a good idea. It's a lot of difficult concepts at once. But maybe it makes sense?

Concepts

• macros

Prerequisites

Come up with something that will put this concept far down the concept tree. Maybe this should depend on a non-existent yet concept of dynamically defining functions without macros? (see #583 (comment))

Practice exercises

Those practice exercises should have macros in their prerequisites and as practices:

• dot-dsl

[Scaletsang]

I am still learning Elixir, but I would like to help as not only I'm in love with functional programming (I started with Haskell and Lisp) but also impressed by how macros in elixir are really expressive. I want to share a few of my thoughts:

Macros are only used when you need to create a new interface for writing codes. In effect, the programmer who uses the macros does not need to know the AST underneath it but only the logo decided by the programmer who writes the macros. If I were to teach a lesson about macros, this is what I will say in order:

1. Revealing that we are always using macros. e.g. defmodule, and test macro in all the test files in every exercise.
2. AST in elixir. The easiest example would be a tuple representation of a function. Here very smoothly can we introduce quote and unquote. One can type in their iex quote do: 1 + 2 and see the AST of 1 + 2.
3. With this understanding, then there will be less ambiguity in learning defmacro, and also less misused because now it should be clear that they are messing with manipulating/ injecting values in an AST and thus only used when you are creating new syntax or creating complex applications.
4. Macros are executed at compilation time. Then introduce some effect of it:

• therefore you cannot have recursion at macros.
• If you want to use macros, you have to compile it first, and hence the require macro which compiles macros from other modules.
• use macro. It does 2 things: Require the macros from another module and run using/1 macro in the specified module to the current module. As a result, it injects code directly from using/1 macro to the current module. ( need to completed import concept first, so that they understand that import is just importing functions and macros, but use and require is about compiling macros from other modules)

So

1. quote&unquote: a little guide about AST, and how quote and unquote can inject values in the AST
2. macros: defmacro, Macro modules
3. require & use

Tell me what do you think!!