Elixir宏 #

defmodule MyMacros do
  defmacro say_hello(name) do
    quote do
      IO.puts("Hello, #{unquote(name)}!")
    end
  end
end

defmodule Example do
  require MyMacros

  def greet do
    MyMacros.say_hello("World")
  end
end

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

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

iex(1)> value = 42
42

iex(2)> quote do: unquote(value)
42

iex(3)> name = :foo
:foo

iex(4)> quote do: def unquote(name)(), do: unquote(value)
{:def, [context: Elixir, imports: [{2, Kernel}]],
 [{:foo, [context: Elixir], Elixir}, [do: 42]]}

iex(1)> values = [1, 2, 3]
[1, 2, 3]

iex(2)> quote do: [0, unquote_splicing(values), 4]
[0, 1, 2, 3, 4]

defmodule MyMacros do
  defmacro log(expr) do
    quote do
      IO.puts("Expression: #{inspect(unquote(Macro.escape(expr)))}")
      result = unquote(expr)
      IO.puts("Result: #{inspect(result)}")
      result
    end
  end
end

require MyMacros

MyMacros.log(1 + 2)
# Expression: {:+, [], [1, 2]}
# Result: 3
# 3

defmodule AttrReader do
  defmacro defattr(name, default \\ nil) do
    quote do
      def unquote(name)(), do: @attrs[unquote(name)] || unquote(default)

      def unquote(:"#{name}!")() do
        @attrs[unquote(name)] || raise "#{unquote(name)} not set"
      end
    end
  end
end

defmodule Config do
  require AttrReader

  @attrs %{host: "localhost", port: 8080}

  AttrReader.defattr(:host)
  AttrReader.defattr(:port)
  AttrReader.defattr(:ssl, false)
end

Config.host()
Config.port()
Config.ssl()

defmodule MyIf do
  defmacro my_if(condition, do: do_clause, else: else_clause) do
    quote do
      case unquote(condition) do
        true -> unquote(do_clause)
        false -> unquote(else_clause)
      end
    end
  end
end

defmodule TestMacros do
  defmacro assert_equal(left, right) do
    quote do
      left = unquote(left)
      right = unquote(right)

      unless left == right do
        raise "Assertion failed: #{inspect(left)} != #{inspect(right)}"
      end
    end
  end
end

defmodule MyModule do
  defmacro __using__(opts) do
    quote do
      import MyModule
      @my_option unquote(opts[:option])
    end
  end

  def my_function, do: "Hello"
end

defmodule Example do
  use MyModule, option: "value"
end

defmodule DynamicModule do
  def create(name, functions) do
    Module.create(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 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
    quote do: :ok
  end
end

defmacro inspect_ast(ast) do
  escaped = Macro.escape(ast)
  quote do
    IO.puts("AST: #{inspect(unquote(escaped))}")
  end
end

defmodule Callback do
  defmacro __using__(_opts) do
    quote do
      Module.register_attribute(__MODULE__, :callbacks, accumulate: true)
      import Callback
    end
  end

  defmacro callback(name) do
    quote do
      @callbacks unquote(name)
    end
  end
end

defmodule Inject do
  defmacro __before_compile__(env) do
    callbacks = Module.get_attribute(env.module, :callbacks)

    quote do
      def callbacks, do: unquote(callbacks)
    end
  end
end

iex(1)> ast = quote do: MyMacro.example()
iex(2)> Macro.expand(ast, __ENV__)

iex(1)> ast = quote do: 1 + 2 * 3
iex(2)> Macro.to_string(ast)
"1 + 2 * 3"