Points qui dansent

Utilisation

La macro use permet d'étendre rapidement notre module avec des fonctionnalités fournies par un autre module. Quand on use un module, ce module peut injecter du code dans notre module : il peut par exemple définir des fonctions, faire un import ou un alias d'autres modules, ou définir des attributs de module.

Si tu as déjà jeté un œil aux fichiers de test de certains exercices Elixir ici, sur Exercism, tu as sans doute remarqué qu'ils commencent tous par use ExUnit.Case. Cette seule ligne de code suffit à rendre les macros test et assert disponibles dans le module de test.

defmodule LasagnaTest do
  use ExUnit.Case

  test "expected minutes in oven" do
    assert Lasagna.expected_minutes_in_oven() === 40
  end
end

La macro __using__/1

Ce qui se passe exactement quand on use un module est dicté par la macro __using__/1 de ce module. Elle prend un argument, une liste de mots-clés contenant les options, et renvoie une expression quotée. Le code de cette expression quotée est inséré dans notre module lors de l'appel à use.

defmodule ExUnit.Case do
  defmacro __using__(opts) do
    # some real-life ExUnit code omitted here
    quote do
      import ExUnit.Assertions
      import ExUnit.Case, only: [describe: 2, test: 1, test: 2, test: 3]
    end
  end
end

Les options peuvent être passées en deuxième argument lors de l'appel à use, par exemple use ExUnit.Case, async: true. Si on ne les fournit pas explicitement, elles valent par défaut une liste vide.

Les behaviours

Les behaviours permettent de définir des interfaces (des ensembles de fonctions et de macros) dans un module de behaviour qui peut ensuite être implémenté par différents modules de callback. Grâce à l'interface partagée, ces modules de callback sont interchangeables.

Définis des behaviours

Pour définir un behaviour, il faut créer un nouveau module et préciser la liste des fonctions qui font partie de l'interface souhaitée. Chaque fonction doit être définie à l'aide de l'attribut de module @callback. La syntaxe est identique à celle d'une spécification de type de fonction (@spec). Il faut préciser le nom de la fonction, une liste de types d'arguments et tous les types de retour possibles.

defmodule Countable do
  @callback count(collection :: any) :: pos_integer
end

Implémente des behaviours

Pour ajouter un behaviour existant à notre module (et donc créer un module de callback), on utilise l'attribut de module @behaviour. Sa valeur doit être le nom du module de behaviour que l'on ajoute.

Ensuite, il faut définir toutes les fonctions (callbacks) exigées par ce module de behaviour. Si on implémente le behaviour de quelqu'un d'autre, comme les behaviours Access ou GenServer fournis avec Elixir, on trouve la liste de tous les callbacks de ce behaviour dans la documentation sur hexdocs.pm.

Un module de callback n'est pas limité aux fonctions qui font partie de son behaviour. Un même module peut aussi implémenter plusieurs behaviours.

Pour indiquer de quel behaviour vient chaque fonction, on utilise l'attribut de module @impl avant chaque fonction. Sa valeur doit être le nom du module de behaviour qui définit ce callback.

defmodule BookCollection do
  @behaviour Countable

  defstruct [:list, :owner]

  @impl Countable
  def count(collection) do
    Enum.count(collection.list)
  end

  def mark_as_read(collection, book) do
    # other function unrelated to the Countable behaviour
  end
end

Implémentations par défaut des callbacks

Lorsqu'on définit un behaviour, il est possible de fournir une implémentation par défaut d'un callback. Cette implémentation doit être définie dans l'expression quotée de la macro __using__/1. Pour permettre aux utilisateurs du module de behaviour de remplacer l'implémentation par défaut, appelle la macro defoverridable/1 après l'implémentation de la fonction. Elle prend une liste de mots-clés dont les clés sont des noms de fonctions et les valeurs des arités de fonctions.

defmodule Countable do
  @callback count(collection :: any) :: pos_integer

  defmacro __using__(_) do
    quote do
      @behaviour Countable
      def count(collection), do: Enum.count(collection)
      defoverridable count: 1
    end
  end
end

Note que définir des fonctions à l'intérieur de __using__/1 est déconseillé pour tout autre usage que définir des implémentations de callbacks par défaut, mais tu peux toujours définir des fonctions dans un autre module et les importer dans la macro __using__/1.