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

# The `Assertion` module
Now that our `assert` macro is in place, we can implement the proxy assert functions in a new `Assertion.Test` module. The `Assertion.Test` module will carry out the work of performing the assertions and running our tests. 



When we find ourselves at a stage in code where we’ve proxied out to a function that we are about to implement, try to think about how pattern matching can help guide our implementation. Let’s see how to use the virtual machine while doing it.

We'll change the project used in our previous example in the following way:

defmodule Assertion do

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

defmodule Assertion.Test do                                         
  def assert(:==, lhs, rhs) when lhs == rhs do
    IO.write "."
  end
  def assert(:==, lhs, rhs) do
    IO.puts """
    FAILURE:
      Expected:       #{lhs}
      to be equal to: #{rhs}
    """
  end

  def assert(:>, lhs, rhs) when lhs > rhs do
    IO.write "."
  end
  def assert(:>, lhs, rhs) do
    IO.puts """
    FAILURE:
      Expected:           #{lhs}
      to be greater than: #{rhs}
    """
  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


By generating a single line of code on **line** __5__ to proxy to `Assertion.Test.assert`, we let the virtual machine’s pattern matching take over to report the result of each assertion. We also placed the functions under a new `Test` module so our `Assertion` imports won’t leak into the caller’s module. We only want the caller to import the `Assertion` macros, so we delegate to another module to avoid importing unnecessary functions.

This also highlights an effective approach to macros: the goal is to generate as little code as possible within the caller’s context. By proxying to an outside function, we keep the code generation as straightforward as possible. This approach is pivotal to writing maintainable macros.
To make some assertions, we simply need to write an `Assertion.Test.assert` definition for each operator in Elixir and display the relevant failure messages. 

First, let’s explore our current implementation in `iex`. Run the project and execute the following assertions:
``` elixir
iex> c "assertion.exs"
# Output: [Assertion.Test, Assertion]

iex> import Assertion
# Output: nil

iex> assert 1 > 2
# Output:
# FAILURE:
#  Expected:           1
#  to be greater than: 2

# :ok

iex> assert 5 == 5
# Output: .:ok

iex> assert 10 * 10 == 100
# Output: .:ok
```


Learn how to make the virtual machine do maximum work while keeping our code clear and concise.

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

Leveraging the Virtual Machine’s Pattern Matching Engine

The `Assertion` module

Code Generation from Git API

Leveraging the Virtual Machine’s Pattern Matching Engine

The Assertion module

The `Assertion` module