Are macros lazily evaluated?

Questions / Help
,
1

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?

2

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
3

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