Are macros lazily evaluated?

I am watching this talk by Jesse Anderson at ElixirConf about how macros work. He creates a macro (if statement), then contrasts it with a functional example.

Macro Version:

defmodule MyMacros 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

Function version:

defmodule MyFunctions do
  def my_if(condition, do: do_clause, else: else_clause) do
     case condition do
        true -> do_clause
        false -> else_clause
      end
   end
end

If you were to call my_if 1 + 2 == 3, do: "this", else: "that", you get the same result from either module. But if evaluation order matters in the do/else blocks, the behavior is different.

iex(17)> MyMacros.my_if 1 + 2 == 3, do: IO.puts("this"), else: IO.puts("that")
this
:ok
iex(18)> MyFunctions.my_if 1 + 2 == 3, do: IO.puts("this"), else: IO.puts("that")
this
that
:ok

Is this considered an example of lazy evaluation, or is this deferred evaluation typically described some other way?

Your macro isn’t perdorming any kind of evaluation, lazy or strict. The macro works because it expands into a case special form, which does allow you to pick branches. In a sense I guess the case macros is doing something that can be considered lazy evaluation.

But your if macro is not performing lazy evaluation. It’s just expanding into another syntax form.

3 Likes

A macro is replaced with the AST that it returns. So, this:

MyMacros.my_if 1 + 2 == 3, do: IO.puts("this"), else: IO.puts("that")

Turns into this at compile time:

case 1 + 2 == 3 do
  true -> IO.puts("this")
  false -> IO.puts("that")
end

Like @tmbb said, case is lazy. Not the macro.

The function appears non-lazy, because the arguments have to be evaluated before they are passed to MyFunctions.my_if/2.

3 Likes