Elixir元编程 #

iex(1)> quote do: 1 + 2
{:+, [context: Elixir, imports: [{2, Kernel}]], [1, 2]}

iex(2)> quote do: x = 1
{:=, [], [{:x, [], Elixir}, 1]}

iex(1)> ast = quote do: foo(1, 2, 3)
{{:., [], [{:__aliases__, [alias: false], [:foo]}]}, [], [1, 2, 3]}

iex(1)> quote do: 42
42

iex(2)> quote do: :atom
:atom

iex(3)> quote do: "string"
"string"

iex(1)> ast = quote do: 1 + 2 * 3
{:+, [], [1, {:*, [], [2, 3]}]}

iex(2)> Macro.to_string(ast)
"1 + 2 * 3"

iex(1)> Macro.var(:x, nil)
{:x, [], nil}

iex(1)> Macro.escape([1, 2, 3])
[1, 2, 3]

iex(2)> Macro.escape(%{a: 1})
{:%{}, [], [a: 1]}

iex(1)> ast = quote do: Kernel.is_atom(:hello)
iex(2)> Macro.expand(ast, __ENV__)
true

iex(1)> ast = quote do: 1 + 2 * 3
iex(2)> Macro.prewalk(ast, fn node -> IO.inspect(node); {node, nil} end)

iex(1)> Macro.postwalk(ast, fn node -> IO.inspect(node); {node, nil} end)

defmodule Transformer do
  def double_numbers(ast) do
    Macro.prewalk(ast, fn
      n when is_number(n) -> n * 2
      other -> other
    end)
  end
end

defmodule DynamicFunctions do
  Enum.each([:foo, :bar, :baz], fn name ->
    def unquote(name)(), do: unquote(name)
  end)
end

defmodule ModuleFactory do
  def create_module(name, functions) do
    module_name = Module.concat([name])

    Module.create(module_name, quote do
      unquote_splicing(
        Enum.map(functions, fn {name, body} ->
          quote do
            def unquote(name)(), do: unquote(body)
          end
        end)
      )
    end, Macro.Env.location(__ENV__))
  end
end

defmodule StructBuilder do
  defmacro defdata(fields) do
    quote do
      defstruct unquote(fields)

      def new(attrs \\ %{}) do
        struct(__MODULE__, attrs)
      end
    end
  end
end

defmodule Tracer do
  defmacro __before_compile__(env) do
    functions = Module.definitions_in(env.module, :def)

    quote do
      def __functions__, do: unquote(Macro.escape(functions))
    end
  end
end

defmodule Example do
  @before_compile Tracer

  def foo, do: 1
  def bar, do: 2
end

defmodule MethodTracker do
  def __on_definition__(env, kind, name, args, guards, body) do
    IO.puts("#{kind} #{name}/#{length(args)}")
  end
end

defmodule Example do
  @on_definition MethodTracker

  def foo(a, b), do: a + b
end

defmodule Example do
  @after_compile __MODULE__

  def __after_compile__(env, bytecode) do
    IO.puts("Module compiled!")
  end
end

defmodule MyAttr do
  Module.register_attribute(__MODULE__, :callbacks, accumulate: true)

  defmacro callback(name) do
    quote do
      @callbacks {unquote(name), __ENV__.line}
    end
  end
end

defmodule Example do
  import MyAttr

  callback :before_save
  callback :after_save

  def callbacks, do: @callbacks
end

defmodule Good do
  defmacro simple do
    quote do: 1 + 1
  end
end

defmodule Bad do
  defmacro complex do
    # 避免复杂的元编程逻辑
    ...
  end
end

defmodule MyMacro do
  @doc """
  Documentation for the macro.

  ## Examples

      iex> MyMacro.example()
      :ok

  """
  defmacro example do
    ...
  end
end

defmodule MyMacroTest do
  use ExUnit.Case

  test "macro expansion" do
    assert Macro.expand(quote(do: MyMacro.example()), __ENV__) == expected_ast
  end
end