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

# `Macro.to_string`: Making sense of our generated code

`Macro.to_string` takes an AST and produces a string of the high-level Elixir source. It’s incredibly helpful when debugging our generated ASTs, especially for cases where many function heads are generated, such as in our `Translator` module. 

# The project

Let’s inspect the generated code that `compile` has produced so far by adding the following changes to our `Translator` module:

defmodule I18n do
  use Translator

  locale "en",
    flash: [
      hello: "Hello %{first} %{last}!",
      bye: "Bye, %{name}!"
    ],
    users: [
      title: "Users",
    ]

  locale "fr",
    flash: [
      hello: "Salut %{first} %{last}!",
      bye: "Au revoir, %{name}!"
    ],
    users: [
      title: "Utilisateurs",
    ]
end

defmodule Translator do

  defmacro __using__(_options) do
    quote do
      Module.register_attribute __MODULE__, :locales, accumulate: true,
                                                      persist: false
      import unquote(__MODULE__), only: [locale: 2]
      @before_compile unquote(__MODULE__)
    end
  end

  defmacro __before_compile__(env) do
    compile(Module.get_attribute(env.module, :locales))
  end

  defmacro locale(name, mappings) do
    quote bind_quoted: [name: name, mappings: mappings] do
      @locales {name, mappings}
    end
  end

  def compile(translations) do
    translations_ast = for {locale, mappings} <- translations do
      deftranslations(locale, "", mappings)
    end

    final_ast = quote do 
      def t(locale, path, binding \\ [])
      unquote(translations_ast)
      def t(_locale, _path, _bindings), do: {:error, :no_translation}
    end

    IO.puts Macro.to_string(final_ast) 
    final_ast
  end

  defp deftranslations(locale, current_path, translations) do
    for {key, val} <- translations do
      path = append_path(current_path, key)
      if Keyword.keyword?(val) do
        deftranslations(locale, path, val)
      else
        quote do
          def t(unquote(locale), unquote(path), bindings) do
            unquote(interpolate(val, :bindings))
          end
        end
      end
    end
  end

  defp append_path("", next), do: to_string(next)
  defp append_path(current, next), do: "#{current}.#{next}"

  defp interpolate(string) do 
    ~r/(?<head>)%{[^}]+}(?<tail>)/
    |> Regex.split(string, on: [:head, :tail])
    |> Enum.reduce "", fn
      <<"%{" <> rest>>, acc ->
        key = String.to_atom(String.rstrip(rest, ?}))
        quote do 
          unquote(acc) <> to_string(Dict.fetch!(bindings, unquote(key)))
        end
      segment, acc -> quote do: (unquote(acc) <> unquote(segment)) 
    end
  end
end


import React from 'react';
import { shallow, configure } from 'enzyme';
import Adapter from 'enzyme-adapter-react-16';

configure({ adapter: new Adapter() });

import HelloWorld from './app';

var TestResult = function() {
    this.succeeded = false;
    this.reason = "";
    this.input = "";
    this.expected_output = "";
    this.actual_output = "";
}

export const executeTests = function() {

  var results = [];

  result = new TestResult();
  result.input = 'HelloWorld Component';
  result.expected_output = "span containing text 'Hello World'"

  let wrapper = shallow(<HelloWorld />);

  // Call your Challenge function here.

  let type = wrapper.type();
  let testSuccessful = true;
  let failureReason;

  if (type !== 'span') {
    testSuccessful = false;
    failureReason = "You need to render exactly one span HTML element";
  } else if (wrapper.props().children != "Hello World") {
     testSuccessful = false;
     failureReason = "You have rendered wrong message in your span element";
  }

  result.actual_output = wrapper.html();

  if (testSuccessful) {
    result.succeeded = true;
    result.reason = "Succeeded"
  } else {
    result.succeeded = false;
    result.reason = failureReason;
  }

  results.push(result);

  return results;
}


React

Dart

GoJS React

Typescript React

Vue.js

On **line** __6__, we stored the result of the generated AST in a `final_ast` binding. Then on **line** __12__, we printed the entire AST expanded as Elixir source using `Macro.to_string`. 
To finish, we returned the `final_ast` as the last result to maintain the compile return signature. 

Let's load our file back up in `iex` and see the results of our code generation so far:

Learn about Macro.to_string and finalize building the Internalization Library 

Finalize Building Our Internationalization Library

Learn about Macro.to_string and finalize building the Internalization Library

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!)

Finalize Building Our Internationalization Library

`Macro.to_string`: Making sense of our generated code

The project

Code Generation from Git API

Finalize Building Our Internationalization Library

Macro.to_string: Making sense of our generated code

The project

`Macro.to_string`: Making sense of our generated code